Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x0139 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0139, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x6ddd1713 0019 11 GT 001A 61 PUSH2 0x00ab 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00ab, if 0x6ddd1713 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x6ddd1713 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa8aa1b31 0024 11 GT 0025 61 PUSH2 0x006f 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xa8aa1b31 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa8aa1b31 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xa8aa1b31 002F 14 EQ 0030 61 PUSH2 0x0425 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0425, if 0xa8aa1b31 == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xa8aa1b31 == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xa9059cbb 003A 14 EQ 003B 61 PUSH2 0x0450 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0450, if 0xa9059cbb == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xa9059cbb == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xdd62ed3e 0045 14 EQ 0046 61 PUSH2 0x048d 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048d, if 0xdd62ed3e == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe96fada2 0050 14 EQ 0051 61 PUSH2 0x04ca 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ca, if 0xe96fada2 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe96fada2 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf1d5f517 005B 14 EQ 005C 61 PUSH2 0x04f5 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f5, if 0xf1d5f517 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf1d5f517 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf887ea40 0066 14 EQ 0067 61 PUSH2 0x051e 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051e, if 0xf887ea40 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf887ea40 == stack[-1] 006B 61 PUSH2 0x0140 006E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0140 label_006F: // Incoming jump from 0x0028, if 0xa8aa1b31 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0x6ddd1713 0076 14 EQ 0077 61 PUSH2 0x0350 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0350, if 0x6ddd1713 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x6ddd1713 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0x70a08231 0081 14 EQ 0082 61 PUSH2 0x037b 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037b, if 0x70a08231 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0x70a08231 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0x715018a6 008C 14 EQ 008D 61 PUSH2 0x03b8 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b8, if 0x715018a6 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0x715018a6 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0x893d20e8 0097 14 EQ 0098 61 PUSH2 0x03cf 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cf, if 0x893d20e8 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0x893d20e8 == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0x95d89b41 00A2 14 EQ 00A3 61 PUSH2 0x03fa 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fa, if 0x95d89b41 == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0x95d89b41 == stack[-1] 00A7 61 PUSH2 0x0140 00AA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0140 label_00AB: // Incoming jump from 0x001D, if 0x6ddd1713 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00AC stack[-1] } 00AB 5B JUMPDEST 00AC 80 DUP1 00AD 63 PUSH4 0x2f54bf6e 00B2 11 GT 00B3 61 PUSH2 0x00fd 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fd, if 0x2f54bf6e > stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x2f54bf6e > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x2f54bf6e 00BD 14 EQ 00BE 61 PUSH2 0x0240 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0240, if 0x2f54bf6e == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x2f54bf6e == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x313ce567 00C8 14 EQ 00C9 61 PUSH2 0x027d 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027d, if 0x313ce567 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x313ce567 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x364333f4 00D3 14 EQ 00D4 61 PUSH2 0x02a8 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a8, if 0x364333f4 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x364333f4 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0x52f7c988 00DE 14 EQ 00DF 61 PUSH2 0x02bf 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bf, if 0x52f7c988 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0x52f7c988 == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0x571ac8b0 00E9 14 EQ 00EA 61 PUSH2 0x02e8 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e8, if 0x571ac8b0 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0x571ac8b0 == stack[-1] // Inputs[1] { @00EE stack[-1] } 00EE 80 DUP1 00EF 63 PUSH4 0x6c0a24eb 00F4 14 EQ 00F5 61 PUSH2 0x0325 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0325, if 0x6c0a24eb == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0x6c0a24eb == stack[-1] 00F9 61 PUSH2 0x0140 00FC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0140 label_00FD: // Incoming jump from 0x00B6, if 0x2f54bf6e > stack[-1] // Inputs[1] { @00FE stack[-1] } 00FD 5B JUMPDEST 00FE 80 DUP1 00FF 63 PUSH4 0x0445b667 0104 14 EQ 0105 61 PUSH2 0x0145 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0145, if 0x0445b667 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x0445b667 == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x06fdde03 010F 14 EQ 0110 61 PUSH2 0x0170 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0170, if 0x06fdde03 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x095ea7b3 011A 14 EQ 011B 61 PUSH2 0x019b 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019b, if 0x095ea7b3 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x18160ddd 0125 14 EQ 0126 61 PUSH2 0x01d8 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d8, if 0x18160ddd == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x18160ddd == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x23b872dd 0130 14 EQ 0131 61 PUSH2 0x0203 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0203, if 0x23b872dd == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x23b872dd == stack[-1] 0135 61 PUSH2 0x0140 0138 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0140 label_0139: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @013A msg.data.length } 0139 5B JUMPDEST 013A 36 CALLDATASIZE 013B 61 PUSH2 0x0140 013E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0140, if msg.data.length label_013F: // Incoming jump from 0x013E, if not msg.data.length 013F 00 *STOP // Stack delta = +0 // Outputs[1] { @013F stop(); } // Block terminates label_0140: // Incoming jump from 0x013E, if msg.data.length // Incoming jump from 0x006E // Incoming jump from 0x0138 // Incoming jump from 0x00FC // Incoming jump from 0x00AA // Inputs[1] { @0144 memory[0x00:0x00] } 0140 5B JUMPDEST 0141 60 PUSH1 0x00 0143 80 DUP1 0144 FD *REVERT // Stack delta = +0 // Outputs[1] { @0144 revert(memory[0x00:0x00]); } // Block terminates label_0145: // Incoming jump from 0x0108, if 0x0445b667 == stack[-1] // Inputs[1] { @0146 msg.value } 0145 5B JUMPDEST 0146 34 CALLVALUE 0147 80 DUP1 0148 15 ISZERO 0149 61 PUSH2 0x0151 014C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0146 stack[0] = msg.value } // Block ends with conditional jump to 0x0151, if !msg.value label_014D: // Incoming jump from 0x014C, if not !msg.value // Inputs[1] { @0150 memory[0x00:0x00] } 014D 60 PUSH1 0x00 014F 80 DUP1 0150 FD *REVERT // Stack delta = +0 // Outputs[1] { @0150 revert(memory[0x00:0x00]); } // Block terminates label_0151: // Incoming jump from 0x014C, if !msg.value 0151 5B JUMPDEST 0152 50 POP 0153 61 PUSH2 0x015a 0156 61 PUSH2 0x0549 0159 56 *JUMP // Stack delta = +0 // Outputs[1] { @0153 stack[-1] = 0x015a } // Block ends with call to 0x0549, returns to 0x015A label_015A: // Incoming return from call to 0x0549 at 0x0159 // Inputs[2] // { // @015D memory[0x40:0x60] // @0161 stack[-1] // } 015A 5B JUMPDEST 015B 60 PUSH1 0x40 015D 51 MLOAD 015E 61 PUSH2 0x0167 0161 91 SWAP2 0162 90 SWAP1 0163 61 PUSH2 0x224d 0166 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0161 stack[-1] = 0x0167 // @0162 stack[1] = memory[0x40:0x60] // @0162 stack[0] = stack[-1] // } // Block ends with call to 0x224d, returns to 0x0167 label_0167: // Incoming return from call to 0x224D at 0x0166 // Inputs[3] // { // @016A memory[0x40:0x60] // @016C stack[-1] // @016F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0167 5B JUMPDEST 0168 60 PUSH1 0x40 016A 51 MLOAD 016B 80 DUP1 016C 91 SWAP2 016D 03 SUB 016E 90 SWAP1 016F F3 *RETURN // Stack delta = -1 // Outputs[1] { @016F return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0170: // Incoming jump from 0x0113, if 0x06fdde03 == stack[-1] // Inputs[1] { @0171 msg.value } 0170 5B JUMPDEST 0171 34 CALLVALUE 0172 80 DUP1 0173 15 ISZERO 0174 61 PUSH2 0x017c 0177 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0171 stack[0] = msg.value } // Block ends with conditional jump to 0x017c, if !msg.value label_0178: // Incoming jump from 0x0177, if not !msg.value // Inputs[1] { @017B memory[0x00:0x00] } 0178 60 PUSH1 0x00 017A 80 DUP1 017B FD *REVERT // Stack delta = +0 // Outputs[1] { @017B revert(memory[0x00:0x00]); } // Block terminates label_017C: // Incoming jump from 0x0177, if !msg.value 017C 5B JUMPDEST 017D 50 POP 017E 61 PUSH2 0x0185 0181 61 PUSH2 0x054f 0184 56 *JUMP // Stack delta = +0 // Outputs[1] { @017E stack[-1] = 0x0185 } // Block ends with call to 0x054f, returns to 0x0185 label_0185: // Incoming return from call to 0x054F at 0x0184 // Inputs[2] // { // @0188 memory[0x40:0x60] // @018C stack[-1] // } 0185 5B JUMPDEST 0186 60 PUSH1 0x40 0188 51 MLOAD 0189 61 PUSH2 0x0192 018C 91 SWAP2 018D 90 SWAP1 018E 61 PUSH2 0x218b 0191 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @018C stack[-1] = 0x0192 // @018D stack[1] = memory[0x40:0x60] // @018D stack[0] = stack[-1] // } // Block ends with call to 0x218b, returns to 0x0192 label_0192: // Incoming return from call to 0x218B at 0x0191 // Inputs[3] // { // @0195 memory[0x40:0x60] // @0197 stack[-1] // @019A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0192 5B JUMPDEST 0193 60 PUSH1 0x40 0195 51 MLOAD 0196 80 DUP1 0197 91 SWAP2 0198 03 SUB 0199 90 SWAP1 019A F3 *RETURN // Stack delta = -1 // Outputs[1] { @019A return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_019B: // Incoming jump from 0x011E, if 0x095ea7b3 == stack[-1] // Inputs[1] { @019C msg.value } 019B 5B JUMPDEST 019C 34 CALLVALUE 019D 80 DUP1 019E 15 ISZERO 019F 61 PUSH2 0x01a7 01A2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @019C stack[0] = msg.value } // Block ends with conditional jump to 0x01a7, if !msg.value label_01A3: // Incoming jump from 0x01A2, if not !msg.value // Inputs[1] { @01A6 memory[0x00:0x00] } 01A3 60 PUSH1 0x00 01A5 80 DUP1 01A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A6 revert(memory[0x00:0x00]); } // Block terminates label_01A7: // Incoming jump from 0x01A2, if !msg.value // Inputs[1] { @01AF msg.data.length } 01A7 5B JUMPDEST 01A8 50 POP 01A9 61 PUSH2 0x01c2 01AC 60 PUSH1 0x04 01AE 80 DUP1 01AF 36 CALLDATASIZE 01B0 03 SUB 01B1 81 DUP2 01B2 01 ADD 01B3 90 SWAP1 01B4 61 PUSH2 0x01bd 01B7 91 SWAP2 01B8 90 SWAP1 01B9 61 PUSH2 0x1dda 01BC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01A9 stack[-1] = 0x01c2 // @01B7 stack[0] = 0x01bd // @01B8 stack[2] = 0x04 // @01B8 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1dda, returns to 0x01BD label_01BD: // Incoming return from call to 0x1DDA at 0x01BC 01BD 5B JUMPDEST 01BE 61 PUSH2 0x058c 01C1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x058c label_01C2: // Incoming return from call to 0x01BD at 0x01BC // Inputs[2] // { // @01C5 memory[0x40:0x60] // @01C9 stack[-1] // } 01C2 5B JUMPDEST 01C3 60 PUSH1 0x40 01C5 51 MLOAD 01C6 61 PUSH2 0x01cf 01C9 91 SWAP2 01CA 90 SWAP1 01CB 61 PUSH2 0x2155 01CE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01C9 stack[-1] = 0x01cf // @01CA stack[1] = memory[0x40:0x60] // @01CA stack[0] = stack[-1] // } // Block ends with call to 0x2155, returns to 0x01CF label_01CF: // Incoming return from call to 0x2155 at 0x01CE // Inputs[3] // { // @01D2 memory[0x40:0x60] // @01D4 stack[-1] // @01D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01CF 5B JUMPDEST 01D0 60 PUSH1 0x40 01D2 51 MLOAD 01D3 80 DUP1 01D4 91 SWAP2 01D5 03 SUB 01D6 90 SWAP1 01D7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01D7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01D8: // Incoming jump from 0x0129, if 0x18160ddd == stack[-1] // Inputs[1] { @01D9 msg.value } 01D8 5B JUMPDEST 01D9 34 CALLVALUE 01DA 80 DUP1 01DB 15 ISZERO 01DC 61 PUSH2 0x01e4 01DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01D9 stack[0] = msg.value } // Block ends with conditional jump to 0x01e4, if !msg.value label_01E0: // Incoming jump from 0x01DF, if not !msg.value // Inputs[1] { @01E3 memory[0x00:0x00] } 01E0 60 PUSH1 0x00 01E2 80 DUP1 01E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E3 revert(memory[0x00:0x00]); } // Block terminates label_01E4: // Incoming jump from 0x01DF, if !msg.value 01E4 5B JUMPDEST 01E5 50 POP 01E6 61 PUSH2 0x01ed 01E9 61 PUSH2 0x067e 01EC 56 *JUMP // Stack delta = +0 // Outputs[1] { @01E6 stack[-1] = 0x01ed } // Block ends with call to 0x067e, returns to 0x01ED label_01ED: // Incoming return from call to 0x067E at 0x01EC // Inputs[2] // { // @01F0 memory[0x40:0x60] // @01F4 stack[-1] // } 01ED 5B JUMPDEST 01EE 60 PUSH1 0x40 01F0 51 MLOAD 01F1 61 PUSH2 0x01fa 01F4 91 SWAP2 01F5 90 SWAP1 01F6 61 PUSH2 0x224d 01F9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01F4 stack[-1] = 0x01fa // @01F5 stack[1] = memory[0x40:0x60] // @01F5 stack[0] = stack[-1] // } // Block ends with call to 0x224d, returns to 0x01FA label_01FA: // Incoming return from call to 0x224D at 0x01F9 // Inputs[3] // { // @01FD memory[0x40:0x60] // @01FF stack[-1] // @0202 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01FA 5B JUMPDEST 01FB 60 PUSH1 0x40 01FD 51 MLOAD 01FE 80 DUP1 01FF 91 SWAP2 0200 03 SUB 0201 90 SWAP1 0202 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0202 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0203: // Incoming jump from 0x0134, if 0x23b872dd == stack[-1] // Inputs[1] { @0204 msg.value } 0203 5B JUMPDEST 0204 34 CALLVALUE 0205 80 DUP1 0206 15 ISZERO 0207 61 PUSH2 0x020f 020A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0204 stack[0] = msg.value } // Block ends with conditional jump to 0x020f, if !msg.value label_020B: // Incoming jump from 0x020A, if not !msg.value // Inputs[1] { @020E memory[0x00:0x00] } 020B 60 PUSH1 0x00 020D 80 DUP1 020E FD *REVERT // Stack delta = +0 // Outputs[1] { @020E revert(memory[0x00:0x00]); } // Block terminates label_020F: // Incoming jump from 0x020A, if !msg.value // Inputs[1] { @0217 msg.data.length } 020F 5B JUMPDEST 0210 50 POP 0211 61 PUSH2 0x022a 0214 60 PUSH1 0x04 0216 80 DUP1 0217 36 CALLDATASIZE 0218 03 SUB 0219 81 DUP2 021A 01 ADD 021B 90 SWAP1 021C 61 PUSH2 0x0225 021F 91 SWAP2 0220 90 SWAP1 0221 61 PUSH2 0x1d87 0224 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0211 stack[-1] = 0x022a // @021F stack[0] = 0x0225 // @0220 stack[2] = 0x04 // @0220 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1d87, returns to 0x0225 label_0225: // Incoming return from call to 0x1D87 at 0x0224 0225 5B JUMPDEST 0226 61 PUSH2 0x0688 0229 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0688 label_022A: // Incoming return from call to 0x0225 at 0x0224 // Inputs[2] // { // @022D memory[0x40:0x60] // @0231 stack[-1] // } 022A 5B JUMPDEST 022B 60 PUSH1 0x40 022D 51 MLOAD 022E 61 PUSH2 0x0237 0231 91 SWAP2 0232 90 SWAP1 0233 61 PUSH2 0x2155 0236 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0231 stack[-1] = 0x0237 // @0232 stack[1] = memory[0x40:0x60] // @0232 stack[0] = stack[-1] // } // Block ends with call to 0x2155, returns to 0x0237 label_0237: // Incoming return from call to 0x2155 at 0x0236 // Inputs[3] // { // @023A memory[0x40:0x60] // @023C stack[-1] // @023F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0237 5B JUMPDEST 0238 60 PUSH1 0x40 023A 51 MLOAD 023B 80 DUP1 023C 91 SWAP2 023D 03 SUB 023E 90 SWAP1 023F F3 *RETURN // Stack delta = -1 // Outputs[1] { @023F return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0240: // Incoming jump from 0x00C1, if 0x2f54bf6e == stack[-1] // Inputs[1] { @0241 msg.value } 0240 5B JUMPDEST 0241 34 CALLVALUE 0242 80 DUP1 0243 15 ISZERO 0244 61 PUSH2 0x024c 0247 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0241 stack[0] = msg.value } // Block ends with conditional jump to 0x024c, if !msg.value label_0248: // Incoming jump from 0x0247, if not !msg.value // Inputs[1] { @024B memory[0x00:0x00] } 0248 60 PUSH1 0x00 024A 80 DUP1 024B FD *REVERT // Stack delta = +0 // Outputs[1] { @024B revert(memory[0x00:0x00]); } // Block terminates label_024C: // Incoming jump from 0x0247, if !msg.value // Inputs[1] { @0254 msg.data.length } 024C 5B JUMPDEST 024D 50 POP 024E 61 PUSH2 0x0267 0251 60 PUSH1 0x04 0253 80 DUP1 0254 36 CALLDATASIZE 0255 03 SUB 0256 81 DUP2 0257 01 ADD 0258 90 SWAP1 0259 61 PUSH2 0x0262 025C 91 SWAP2 025D 90 SWAP1 025E 61 PUSH2 0x1ced 0261 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @024E stack[-1] = 0x0267 // @025C stack[0] = 0x0262 // @025D stack[2] = 0x04 // @025D stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1ced, returns to 0x0262 label_0262: // Incoming return from call to 0x1CED at 0x0261 0262 5B JUMPDEST 0263 61 PUSH2 0x0888 0266 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0888 label_0267: // Incoming return from call to 0x0262 at 0x0261 // Inputs[2] // { // @026A memory[0x40:0x60] // @026E stack[-1] // } 0267 5B JUMPDEST 0268 60 PUSH1 0x40 026A 51 MLOAD 026B 61 PUSH2 0x0274 026E 91 SWAP2 026F 90 SWAP1 0270 61 PUSH2 0x2155 0273 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @026E stack[-1] = 0x0274 // @026F stack[1] = memory[0x40:0x60] // @026F stack[0] = stack[-1] // } // Block ends with call to 0x2155, returns to 0x0274 label_0274: // Incoming return from call to 0x2155 at 0x0273 // Inputs[3] // { // @0277 memory[0x40:0x60] // @0279 stack[-1] // @027C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0274 5B JUMPDEST 0275 60 PUSH1 0x40 0277 51 MLOAD 0278 80 DUP1 0279 91 SWAP2 027A 03 SUB 027B 90 SWAP1 027C F3 *RETURN // Stack delta = -1 // Outputs[1] { @027C return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_027D: // Incoming jump from 0x00CC, if 0x313ce567 == stack[-1] // Inputs[1] { @027E msg.value } 027D 5B JUMPDEST 027E 34 CALLVALUE 027F 80 DUP1 0280 15 ISZERO 0281 61 PUSH2 0x0289 0284 57 *JUMPI // Stack delta = +1 // Outputs[1] { @027E stack[0] = msg.value } // Block ends with conditional jump to 0x0289, if !msg.value label_0285: // Incoming jump from 0x0284, if not !msg.value // Inputs[1] { @0288 memory[0x00:0x00] } 0285 60 PUSH1 0x00 0287 80 DUP1 0288 FD *REVERT // Stack delta = +0 // Outputs[1] { @0288 revert(memory[0x00:0x00]); } // Block terminates label_0289: // Incoming jump from 0x0284, if !msg.value 0289 5B JUMPDEST 028A 50 POP 028B 61 PUSH2 0x0292 028E 61 PUSH2 0x08e1 0291 56 *JUMP // Stack delta = +0 // Outputs[1] { @028B stack[-1] = 0x0292 } // Block ends with call to 0x08e1, returns to 0x0292 label_0292: // Incoming return from call to 0x08E1 at 0x0291 // Inputs[2] // { // @0295 memory[0x40:0x60] // @0299 stack[-1] // } 0292 5B JUMPDEST 0293 60 PUSH1 0x40 0295 51 MLOAD 0296 61 PUSH2 0x029f 0299 91 SWAP2 029A 90 SWAP1 029B 61 PUSH2 0x22eb 029E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0299 stack[-1] = 0x029f // @029A stack[1] = memory[0x40:0x60] // @029A stack[0] = stack[-1] // } // Block ends with call to 0x22eb, returns to 0x029F label_029F: // Incoming return from call to 0x22EB at 0x029E // Inputs[3] // { // @02A2 memory[0x40:0x60] // @02A4 stack[-1] // @02A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 029F 5B JUMPDEST 02A0 60 PUSH1 0x40 02A2 51 MLOAD 02A3 80 DUP1 02A4 91 SWAP2 02A5 03 SUB 02A6 90 SWAP1 02A7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @02A7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02A8: // Incoming jump from 0x00D7, if 0x364333f4 == stack[-1] // Inputs[1] { @02A9 msg.value } 02A8 5B JUMPDEST 02A9 34 CALLVALUE 02AA 80 DUP1 02AB 15 ISZERO 02AC 61 PUSH2 0x02b4 02AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A9 stack[0] = msg.value } // Block ends with conditional jump to 0x02b4, if !msg.value label_02B0: // Incoming jump from 0x02AF, if not !msg.value // Inputs[1] { @02B3 memory[0x00:0x00] } 02B0 60 PUSH1 0x00 02B2 80 DUP1 02B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B3 revert(memory[0x00:0x00]); } // Block terminates label_02B4: // Incoming jump from 0x02AF, if !msg.value 02B4 5B JUMPDEST 02B5 50 POP 02B6 61 PUSH2 0x02bd 02B9 61 PUSH2 0x08ea 02BC 56 *JUMP // Stack delta = +0 // Outputs[1] { @02B6 stack[-1] = 0x02bd } // Block ends with call to 0x08ea, returns to 0x02BD label_02BD: // Incoming return from call to 0x08EA at 0x02BC 02BD 5B JUMPDEST 02BE 00 *STOP // Stack delta = +0 // Outputs[1] { @02BE stop(); } // Block terminates label_02BF: // Incoming jump from 0x00E2, if 0x52f7c988 == stack[-1] // Inputs[1] { @02C0 msg.value } 02BF 5B JUMPDEST 02C0 34 CALLVALUE 02C1 80 DUP1 02C2 15 ISZERO 02C3 61 PUSH2 0x02cb 02C6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C0 stack[0] = msg.value } // Block ends with conditional jump to 0x02cb, if !msg.value label_02C7: // Incoming jump from 0x02C6, if not !msg.value // Inputs[1] { @02CA memory[0x00:0x00] } 02C7 60 PUSH1 0x00 02C9 80 DUP1 02CA FD *REVERT // Stack delta = +0 // Outputs[1] { @02CA revert(memory[0x00:0x00]); } // Block terminates label_02CB: // Incoming jump from 0x02C6, if !msg.value // Inputs[1] { @02D3 msg.data.length } 02CB 5B JUMPDEST 02CC 50 POP 02CD 61 PUSH2 0x02e6 02D0 60 PUSH1 0x04 02D2 80 DUP1 02D3 36 CALLDATASIZE 02D4 03 SUB 02D5 81 DUP2 02D6 01 ADD 02D7 90 SWAP1 02D8 61 PUSH2 0x02e1 02DB 91 SWAP2 02DC 90 SWAP1 02DD 61 PUSH2 0x1e47 02E0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02CD stack[-1] = 0x02e6 // @02DB stack[0] = 0x02e1 // @02DC stack[2] = 0x04 // @02DC stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1e47, returns to 0x02E1 label_02E1: // Incoming return from call to 0x1E47 at 0x02E0 02E1 5B JUMPDEST 02E2 61 PUSH2 0x0955 02E5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0955 label_02E6: // Incoming return from call to 0x02E1 at 0x02E0 02E6 5B JUMPDEST 02E7 00 *STOP // Stack delta = +0 // Outputs[1] { @02E7 stop(); } // Block terminates label_02E8: // Incoming jump from 0x00ED, if 0x571ac8b0 == stack[-1] // Inputs[1] { @02E9 msg.value } 02E8 5B JUMPDEST 02E9 34 CALLVALUE 02EA 80 DUP1 02EB 15 ISZERO 02EC 61 PUSH2 0x02f4 02EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02E9 stack[0] = msg.value } // Block ends with conditional jump to 0x02f4, if !msg.value label_02F0: // Incoming jump from 0x02EF, if not !msg.value // Inputs[1] { @02F3 memory[0x00:0x00] } 02F0 60 PUSH1 0x00 02F2 80 DUP1 02F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F3 revert(memory[0x00:0x00]); } // Block terminates label_02F4: // Incoming jump from 0x02EF, if !msg.value // Inputs[1] { @02FC msg.data.length } 02F4 5B JUMPDEST 02F5 50 POP 02F6 61 PUSH2 0x030f 02F9 60 PUSH1 0x04 02FB 80 DUP1 02FC 36 CALLDATASIZE 02FD 03 SUB 02FE 81 DUP2 02FF 01 ADD 0300 90 SWAP1 0301 61 PUSH2 0x030a 0304 91 SWAP2 0305 90 SWAP1 0306 61 PUSH2 0x1ced 0309 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02F6 stack[-1] = 0x030f // @0304 stack[0] = 0x030a // @0305 stack[2] = 0x04 // @0305 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1ced, returns to 0x030A label_030A: // Incoming return from call to 0x1CED at 0x0309 030A 5B JUMPDEST 030B 61 PUSH2 0x09c5 030E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09c5 label_030F: // Incoming return from call to 0x030A at 0x0309 // Inputs[2] // { // @0312 memory[0x40:0x60] // @0316 stack[-1] // } 030F 5B JUMPDEST 0310 60 PUSH1 0x40 0312 51 MLOAD 0313 61 PUSH2 0x031c 0316 91 SWAP2 0317 90 SWAP1 0318 61 PUSH2 0x2155 031B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0316 stack[-1] = 0x031c // @0317 stack[1] = memory[0x40:0x60] // @0317 stack[0] = stack[-1] // } // Block ends with call to 0x2155, returns to 0x031C label_031C: // Incoming return from call to 0x2155 at 0x031B // Inputs[3] // { // @031F memory[0x40:0x60] // @0321 stack[-1] // @0324 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 031C 5B JUMPDEST 031D 60 PUSH1 0x40 031F 51 MLOAD 0320 80 DUP1 0321 91 SWAP2 0322 03 SUB 0323 90 SWAP1 0324 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0324 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0325: // Incoming jump from 0x00F8, if 0x6c0a24eb == stack[-1] // Inputs[1] { @0326 msg.value } 0325 5B JUMPDEST 0326 34 CALLVALUE 0327 80 DUP1 0328 15 ISZERO 0329 61 PUSH2 0x0331 032C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0326 stack[0] = msg.value } // Block ends with conditional jump to 0x0331, if !msg.value label_032D: // Incoming jump from 0x032C, if not !msg.value // Inputs[1] { @0330 memory[0x00:0x00] } 032D 60 PUSH1 0x00 032F 80 DUP1 0330 FD *REVERT // Stack delta = +0 // Outputs[1] { @0330 revert(memory[0x00:0x00]); } // Block terminates label_0331: // Incoming jump from 0x032C, if !msg.value 0331 5B JUMPDEST 0332 50 POP 0333 61 PUSH2 0x033a 0336 61 PUSH2 0x09f8 0339 56 *JUMP // Stack delta = +0 // Outputs[1] { @0333 stack[-1] = 0x033a } // Block ends with call to 0x09f8, returns to 0x033A label_033A: // Incoming return from call to 0x09F8 at 0x0339 // Inputs[2] // { // @033D memory[0x40:0x60] // @0341 stack[-1] // } 033A 5B JUMPDEST 033B 60 PUSH1 0x40 033D 51 MLOAD 033E 61 PUSH2 0x0347 0341 91 SWAP2 0342 90 SWAP1 0343 61 PUSH2 0x224d 0346 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0341 stack[-1] = 0x0347 // @0342 stack[1] = memory[0x40:0x60] // @0342 stack[0] = stack[-1] // } // Block ends with call to 0x224d, returns to 0x0347 label_0347: // Incoming return from call to 0x224D at 0x0346 // Inputs[3] // { // @034A memory[0x40:0x60] // @034C stack[-1] // @034F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0347 5B JUMPDEST 0348 60 PUSH1 0x40 034A 51 MLOAD 034B 80 DUP1 034C 91 SWAP2 034D 03 SUB 034E 90 SWAP1 034F F3 *RETURN // Stack delta = -1 // Outputs[1] { @034F return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0350: // Incoming jump from 0x007A, if 0x6ddd1713 == stack[-1] // Inputs[1] { @0351 msg.value } 0350 5B JUMPDEST 0351 34 CALLVALUE 0352 80 DUP1 0353 15 ISZERO 0354 61 PUSH2 0x035c 0357 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0351 stack[0] = msg.value } // Block ends with conditional jump to 0x035c, if !msg.value label_0358: // Incoming jump from 0x0357, if not !msg.value // Inputs[1] { @035B memory[0x00:0x00] } 0358 60 PUSH1 0x00 035A 80 DUP1 035B FD *REVERT // Stack delta = +0 // Outputs[1] { @035B revert(memory[0x00:0x00]); } // Block terminates label_035C: // Incoming jump from 0x0357, if !msg.value 035C 5B JUMPDEST 035D 50 POP 035E 61 PUSH2 0x0365 0361 61 PUSH2 0x09fe 0364 56 *JUMP // Stack delta = +0 // Outputs[1] { @035E stack[-1] = 0x0365 } // Block ends with call to 0x09fe, returns to 0x0365 label_0365: // Incoming return from call to 0x09FE at 0x0364 // Inputs[2] // { // @0368 memory[0x40:0x60] // @036C stack[-1] // } 0365 5B JUMPDEST 0366 60 PUSH1 0x40 0368 51 MLOAD 0369 61 PUSH2 0x0372 036C 91 SWAP2 036D 90 SWAP1 036E 61 PUSH2 0x2155 0371 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @036C stack[-1] = 0x0372 // @036D stack[1] = memory[0x40:0x60] // @036D stack[0] = stack[-1] // } // Block ends with call to 0x2155, returns to 0x0372 label_0372: // Incoming return from call to 0x2155 at 0x0371 // Inputs[3] // { // @0375 memory[0x40:0x60] // @0377 stack[-1] // @037A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0372 5B JUMPDEST 0373 60 PUSH1 0x40 0375 51 MLOAD 0376 80 DUP1 0377 91 SWAP2 0378 03 SUB 0379 90 SWAP1 037A F3 *RETURN // Stack delta = -1 // Outputs[1] { @037A return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_037B: // Incoming jump from 0x0085, if 0x70a08231 == stack[-1] // Inputs[1] { @037C msg.value } 037B 5B JUMPDEST 037C 34 CALLVALUE 037D 80 DUP1 037E 15 ISZERO 037F 61 PUSH2 0x0387 0382 57 *JUMPI // Stack delta = +1 // Outputs[1] { @037C stack[0] = msg.value } // Block ends with conditional jump to 0x0387, if !msg.value label_0383: // Incoming jump from 0x0382, if not !msg.value // Inputs[1] { @0386 memory[0x00:0x00] } 0383 60 PUSH1 0x00 0385 80 DUP1 0386 FD *REVERT // Stack delta = +0 // Outputs[1] { @0386 revert(memory[0x00:0x00]); } // Block terminates label_0387: // Incoming jump from 0x0382, if !msg.value // Inputs[1] { @038F msg.data.length } 0387 5B JUMPDEST 0388 50 POP 0389 61 PUSH2 0x03a2 038C 60 PUSH1 0x04 038E 80 DUP1 038F 36 CALLDATASIZE 0390 03 SUB 0391 81 DUP2 0392 01 ADD 0393 90 SWAP1 0394 61 PUSH2 0x039d 0397 91 SWAP2 0398 90 SWAP1 0399 61 PUSH2 0x1ced 039C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0389 stack[-1] = 0x03a2 // @0397 stack[0] = 0x039d // @0398 stack[2] = 0x04 // @0398 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1ced, returns to 0x039D label_039D: // Incoming return from call to 0x1CED at 0x039C 039D 5B JUMPDEST 039E 61 PUSH2 0x0a11 03A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a11 label_03A2: // Incoming return from call to 0x039D at 0x039C // Inputs[2] // { // @03A5 memory[0x40:0x60] // @03A9 stack[-1] // } 03A2 5B JUMPDEST 03A3 60 PUSH1 0x40 03A5 51 MLOAD 03A6 61 PUSH2 0x03af 03A9 91 SWAP2 03AA 90 SWAP1 03AB 61 PUSH2 0x224d 03AE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03A9 stack[-1] = 0x03af // @03AA stack[1] = memory[0x40:0x60] // @03AA stack[0] = stack[-1] // } // Block ends with call to 0x224d, returns to 0x03AF label_03AF: // Incoming return from call to 0x224D at 0x03AE // Inputs[3] // { // @03B2 memory[0x40:0x60] // @03B4 stack[-1] // @03B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 03AF 5B JUMPDEST 03B0 60 PUSH1 0x40 03B2 51 MLOAD 03B3 80 DUP1 03B4 91 SWAP2 03B5 03 SUB 03B6 90 SWAP1 03B7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @03B7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_03B8: // Incoming jump from 0x0090, if 0x715018a6 == stack[-1] // Inputs[1] { @03B9 msg.value } 03B8 5B JUMPDEST 03B9 34 CALLVALUE 03BA 80 DUP1 03BB 15 ISZERO 03BC 61 PUSH2 0x03c4 03BF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B9 stack[0] = msg.value } // Block ends with conditional jump to 0x03c4, if !msg.value label_03C0: // Incoming jump from 0x03BF, if not !msg.value // Inputs[1] { @03C3 memory[0x00:0x00] } 03C0 60 PUSH1 0x00 03C2 80 DUP1 03C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03C3 revert(memory[0x00:0x00]); } // Block terminates label_03C4: // Incoming jump from 0x03BF, if !msg.value 03C4 5B JUMPDEST 03C5 50 POP 03C6 61 PUSH2 0x03cd 03C9 61 PUSH2 0x0a5a 03CC 56 *JUMP // Stack delta = +0 // Outputs[1] { @03C6 stack[-1] = 0x03cd } // Block ends with call to 0x0a5a, returns to 0x03CD label_03CD: // Incoming return from call to 0x0A5A at 0x03CC 03CD 5B JUMPDEST 03CE 00 *STOP // Stack delta = +0 // Outputs[1] { @03CE stop(); } // Block terminates label_03CF: // Incoming jump from 0x009B, if 0x893d20e8 == stack[-1] // Inputs[1] { @03D0 msg.value } 03CF 5B JUMPDEST 03D0 34 CALLVALUE 03D1 80 DUP1 03D2 15 ISZERO 03D3 61 PUSH2 0x03db 03D6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D0 stack[0] = msg.value } // Block ends with conditional jump to 0x03db, if !msg.value label_03D7: // Incoming jump from 0x03D6, if not !msg.value // Inputs[1] { @03DA memory[0x00:0x00] } 03D7 60 PUSH1 0x00 03D9 80 DUP1 03DA FD *REVERT // Stack delta = +0 // Outputs[1] { @03DA revert(memory[0x00:0x00]); } // Block terminates label_03DB: // Incoming jump from 0x03D6, if !msg.value 03DB 5B JUMPDEST 03DC 50 POP 03DD 61 PUSH2 0x03e4 03E0 61 PUSH2 0x0b1d 03E3 56 *JUMP // Stack delta = +0 // Outputs[1] { @03DD stack[-1] = 0x03e4 } // Block ends with call to 0x0b1d, returns to 0x03E4 label_03E4: // Incoming return from call to 0x0B1D at 0x03E3 // Inputs[2] // { // @03E7 memory[0x40:0x60] // @03EB stack[-1] // } 03E4 5B JUMPDEST 03E5 60 PUSH1 0x40 03E7 51 MLOAD 03E8 61 PUSH2 0x03f1 03EB 91 SWAP2 03EC 90 SWAP1 03ED 61 PUSH2 0x20d9 03F0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03EB stack[-1] = 0x03f1 // @03EC stack[1] = memory[0x40:0x60] // @03EC stack[0] = stack[-1] // } // Block ends with call to 0x20d9, returns to 0x03F1 label_03F1: // Incoming return from call to 0x20D9 at 0x03F0 // Inputs[3] // { // @03F4 memory[0x40:0x60] // @03F6 stack[-1] // @03F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 03F1 5B JUMPDEST 03F2 60 PUSH1 0x40 03F4 51 MLOAD 03F5 80 DUP1 03F6 91 SWAP2 03F7 03 SUB 03F8 90 SWAP1 03F9 F3 *RETURN // Stack delta = -1 // Outputs[1] { @03F9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_03FA: // Incoming jump from 0x00A6, if 0x95d89b41 == stack[-1] // Inputs[1] { @03FB msg.value } 03FA 5B JUMPDEST 03FB 34 CALLVALUE 03FC 80 DUP1 03FD 15 ISZERO 03FE 61 PUSH2 0x0406 0401 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03FB stack[0] = msg.value } // Block ends with conditional jump to 0x0406, if !msg.value label_0402: // Incoming jump from 0x0401, if not !msg.value // Inputs[1] { @0405 memory[0x00:0x00] } 0402 60 PUSH1 0x00 0404 80 DUP1 0405 FD *REVERT // Stack delta = +0 // Outputs[1] { @0405 revert(memory[0x00:0x00]); } // Block terminates label_0406: // Incoming jump from 0x0401, if !msg.value 0406 5B JUMPDEST 0407 50 POP 0408 61 PUSH2 0x040f 040B 61 PUSH2 0x0b46 040E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0408 stack[-1] = 0x040f } // Block ends with call to 0x0b46, returns to 0x040F label_040F: // Incoming return from call to 0x0B46 at 0x040E // Inputs[2] // { // @0412 memory[0x40:0x60] // @0416 stack[-1] // } 040F 5B JUMPDEST 0410 60 PUSH1 0x40 0412 51 MLOAD 0413 61 PUSH2 0x041c 0416 91 SWAP2 0417 90 SWAP1 0418 61 PUSH2 0x218b 041B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0416 stack[-1] = 0x041c // @0417 stack[1] = memory[0x40:0x60] // @0417 stack[0] = stack[-1] // } // Block ends with call to 0x218b, returns to 0x041C label_041C: // Incoming return from call to 0x218B at 0x041B // Inputs[3] // { // @041F memory[0x40:0x60] // @0421 stack[-1] // @0424 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 041C 5B JUMPDEST 041D 60 PUSH1 0x40 041F 51 MLOAD 0420 80 DUP1 0421 91 SWAP2 0422 03 SUB 0423 90 SWAP1 0424 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0424 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0425: // Incoming jump from 0x0033, if 0xa8aa1b31 == stack[-1] // Inputs[1] { @0426 msg.value } 0425 5B JUMPDEST 0426 34 CALLVALUE 0427 80 DUP1 0428 15 ISZERO 0429 61 PUSH2 0x0431 042C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0426 stack[0] = msg.value } // Block ends with conditional jump to 0x0431, if !msg.value label_042D: // Incoming jump from 0x042C, if not !msg.value // Inputs[1] { @0430 memory[0x00:0x00] } 042D 60 PUSH1 0x00 042F 80 DUP1 0430 FD *REVERT // Stack delta = +0 // Outputs[1] { @0430 revert(memory[0x00:0x00]); } // Block terminates label_0431: // Incoming jump from 0x042C, if !msg.value 0431 5B JUMPDEST 0432 50 POP 0433 61 PUSH2 0x043a 0436 61 PUSH2 0x0b83 0439 56 *JUMP // Stack delta = +0 // Outputs[1] { @0433 stack[-1] = 0x043a } // Block ends with call to 0x0b83, returns to 0x043A label_043A: // Incoming return from call to 0x0B83 at 0x0439 // Inputs[2] // { // @043D memory[0x40:0x60] // @0441 stack[-1] // } 043A 5B JUMPDEST 043B 60 PUSH1 0x40 043D 51 MLOAD 043E 61 PUSH2 0x0447 0441 91 SWAP2 0442 90 SWAP1 0443 61 PUSH2 0x20d9 0446 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0441 stack[-1] = 0x0447 // @0442 stack[1] = memory[0x40:0x60] // @0442 stack[0] = stack[-1] // } // Block ends with call to 0x20d9, returns to 0x0447 label_0447: // Incoming return from call to 0x20D9 at 0x0446 // Inputs[3] // { // @044A memory[0x40:0x60] // @044C stack[-1] // @044F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0447 5B JUMPDEST 0448 60 PUSH1 0x40 044A 51 MLOAD 044B 80 DUP1 044C 91 SWAP2 044D 03 SUB 044E 90 SWAP1 044F F3 *RETURN // Stack delta = -1 // Outputs[1] { @044F return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0450: // Incoming jump from 0x003E, if 0xa9059cbb == stack[-1] // Inputs[1] { @0451 msg.value } 0450 5B JUMPDEST 0451 34 CALLVALUE 0452 80 DUP1 0453 15 ISZERO 0454 61 PUSH2 0x045c 0457 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0451 stack[0] = msg.value } // Block ends with conditional jump to 0x045c, if !msg.value label_0458: // Incoming jump from 0x0457, if not !msg.value // Inputs[1] { @045B memory[0x00:0x00] } 0458 60 PUSH1 0x00 045A 80 DUP1 045B FD *REVERT // Stack delta = +0 // Outputs[1] { @045B revert(memory[0x00:0x00]); } // Block terminates label_045C: // Incoming jump from 0x0457, if !msg.value // Inputs[1] { @0464 msg.data.length } 045C 5B JUMPDEST 045D 50 POP 045E 61 PUSH2 0x0477 0461 60 PUSH1 0x04 0463 80 DUP1 0464 36 CALLDATASIZE 0465 03 SUB 0466 81 DUP2 0467 01 ADD 0468 90 SWAP1 0469 61 PUSH2 0x0472 046C 91 SWAP2 046D 90 SWAP1 046E 61 PUSH2 0x1dda 0471 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @045E stack[-1] = 0x0477 // @046C stack[0] = 0x0472 // @046D stack[2] = 0x04 // @046D stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1dda, returns to 0x0472 label_0472: // Incoming return from call to 0x1DDA at 0x0471 0472 5B JUMPDEST 0473 61 PUSH2 0x0ba9 0476 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ba9 label_0477: // Incoming return from call to 0x0472 at 0x0471 // Inputs[2] // { // @047A memory[0x40:0x60] // @047E stack[-1] // } 0477 5B JUMPDEST 0478 60 PUSH1 0x40 047A 51 MLOAD 047B 61 PUSH2 0x0484 047E 91 SWAP2 047F 90 SWAP1 0480 61 PUSH2 0x2155 0483 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @047E stack[-1] = 0x0484 // @047F stack[1] = memory[0x40:0x60] // @047F stack[0] = stack[-1] // } // Block ends with call to 0x2155, returns to 0x0484 label_0484: // Incoming return from call to 0x2155 at 0x0483 // Inputs[3] // { // @0487 memory[0x40:0x60] // @0489 stack[-1] // @048C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0484 5B JUMPDEST 0485 60 PUSH1 0x40 0487 51 MLOAD 0488 80 DUP1 0489 91 SWAP2 048A 03 SUB 048B 90 SWAP1 048C F3 *RETURN // Stack delta = -1 // Outputs[1] { @048C return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_048D: // Incoming jump from 0x0049, if 0xdd62ed3e == stack[-1] // Inputs[1] { @048E msg.value } 048D 5B JUMPDEST 048E 34 CALLVALUE 048F 80 DUP1 0490 15 ISZERO 0491 61 PUSH2 0x0499 0494 57 *JUMPI // Stack delta = +1 // Outputs[1] { @048E stack[0] = msg.value } // Block ends with conditional jump to 0x0499, if !msg.value label_0495: // Incoming jump from 0x0494, if not !msg.value // Inputs[1] { @0498 memory[0x00:0x00] } 0495 60 PUSH1 0x00 0497 80 DUP1 0498 FD *REVERT // Stack delta = +0 // Outputs[1] { @0498 revert(memory[0x00:0x00]); } // Block terminates label_0499: // Incoming jump from 0x0494, if !msg.value // Inputs[1] { @04A1 msg.data.length } 0499 5B JUMPDEST 049A 50 POP 049B 61 PUSH2 0x04b4 049E 60 PUSH1 0x04 04A0 80 DUP1 04A1 36 CALLDATASIZE 04A2 03 SUB 04A3 81 DUP2 04A4 01 ADD 04A5 90 SWAP1 04A6 61 PUSH2 0x04af 04A9 91 SWAP2 04AA 90 SWAP1 04AB 61 PUSH2 0x1d47 04AE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @049B stack[-1] = 0x04b4 // @04A9 stack[0] = 0x04af // @04AA stack[2] = 0x04 // @04AA stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1d47, returns to 0x04AF label_04AF: // Incoming return from call to 0x1D47 at 0x04AE 04AF 5B JUMPDEST 04B0 61 PUSH2 0x0bbe 04B3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bbe label_04B4: // Incoming return from call to 0x04AF at 0x04AE // Inputs[2] // { // @04B7 memory[0x40:0x60] // @04BB stack[-1] // } 04B4 5B JUMPDEST 04B5 60 PUSH1 0x40 04B7 51 MLOAD 04B8 61 PUSH2 0x04c1 04BB 91 SWAP2 04BC 90 SWAP1 04BD 61 PUSH2 0x224d 04C0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04BB stack[-1] = 0x04c1 // @04BC stack[1] = memory[0x40:0x60] // @04BC stack[0] = stack[-1] // } // Block ends with call to 0x224d, returns to 0x04C1 label_04C1: // Incoming return from call to 0x224D at 0x04C0 // Inputs[3] // { // @04C4 memory[0x40:0x60] // @04C6 stack[-1] // @04C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 04C1 5B JUMPDEST 04C2 60 PUSH1 0x40 04C4 51 MLOAD 04C5 80 DUP1 04C6 91 SWAP2 04C7 03 SUB 04C8 90 SWAP1 04C9 F3 *RETURN // Stack delta = -1 // Outputs[1] { @04C9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_04CA: // Incoming jump from 0x0054, if 0xe96fada2 == stack[-1] // Inputs[1] { @04CB msg.value } 04CA 5B JUMPDEST 04CB 34 CALLVALUE 04CC 80 DUP1 04CD 15 ISZERO 04CE 61 PUSH2 0x04d6 04D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CB stack[0] = msg.value } // Block ends with conditional jump to 0x04d6, if !msg.value label_04D2: // Incoming jump from 0x04D1, if not !msg.value // Inputs[1] { @04D5 memory[0x00:0x00] } 04D2 60 PUSH1 0x00 04D4 80 DUP1 04D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D5 revert(memory[0x00:0x00]); } // Block terminates label_04D6: // Incoming jump from 0x04D1, if !msg.value 04D6 5B JUMPDEST 04D7 50 POP 04D8 61 PUSH2 0x04df 04DB 61 PUSH2 0x0c45 04DE 56 *JUMP // Stack delta = +0 // Outputs[1] { @04D8 stack[-1] = 0x04df } // Block ends with call to 0x0c45, returns to 0x04DF label_04DF: // Incoming return from call to 0x0C45 at 0x04DE // Inputs[2] // { // @04E2 memory[0x40:0x60] // @04E6 stack[-1] // } 04DF 5B JUMPDEST 04E0 60 PUSH1 0x40 04E2 51 MLOAD 04E3 61 PUSH2 0x04ec 04E6 91 SWAP2 04E7 90 SWAP1 04E8 61 PUSH2 0x20d9 04EB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04E6 stack[-1] = 0x04ec // @04E7 stack[1] = memory[0x40:0x60] // @04E7 stack[0] = stack[-1] // } // Block ends with call to 0x20d9, returns to 0x04EC label_04EC: // Incoming return from call to 0x20D9 at 0x04EB // Inputs[3] // { // @04EF memory[0x40:0x60] // @04F1 stack[-1] // @04F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 04EC 5B JUMPDEST 04ED 60 PUSH1 0x40 04EF 51 MLOAD 04F0 80 DUP1 04F1 91 SWAP2 04F2 03 SUB 04F3 90 SWAP1 04F4 F3 *RETURN // Stack delta = -1 // Outputs[1] { @04F4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_04F5: // Incoming jump from 0x005F, if 0xf1d5f517 == stack[-1] // Inputs[1] { @04F6 msg.value } 04F5 5B JUMPDEST 04F6 34 CALLVALUE 04F7 80 DUP1 04F8 15 ISZERO 04F9 61 PUSH2 0x0501 04FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F6 stack[0] = msg.value } // Block ends with conditional jump to 0x0501, if !msg.value label_04FD: // Incoming jump from 0x04FC, if not !msg.value // Inputs[1] { @0500 memory[0x00:0x00] } 04FD 60 PUSH1 0x00 04FF 80 DUP1 0500 FD *REVERT // Stack delta = +0 // Outputs[1] { @0500 revert(memory[0x00:0x00]); } // Block terminates label_0501: // Incoming jump from 0x04FC, if !msg.value // Inputs[1] { @0509 msg.data.length } 0501 5B JUMPDEST 0502 50 POP 0503 61 PUSH2 0x051c 0506 60 PUSH1 0x04 0508 80 DUP1 0509 36 CALLDATASIZE 050A 03 SUB 050B 81 DUP2 050C 01 ADD 050D 90 SWAP1 050E 61 PUSH2 0x0517 0511 91 SWAP2 0512 90 SWAP1 0513 61 PUSH2 0x1e1a 0516 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0503 stack[-1] = 0x051c // @0511 stack[0] = 0x0517 // @0512 stack[2] = 0x04 // @0512 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1e1a, returns to 0x0517 label_0517: // Incoming return from call to 0x1E1A at 0x0516 0517 5B JUMPDEST 0518 61 PUSH2 0x0c6b 051B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c6b label_051C: // Incoming return from call to 0x0517 at 0x0516 051C 5B JUMPDEST 051D 00 *STOP // Stack delta = +0 // Outputs[1] { @051D stop(); } // Block terminates label_051E: // Incoming jump from 0x006A, if 0xf887ea40 == stack[-1] // Inputs[1] { @051F msg.value } 051E 5B JUMPDEST 051F 34 CALLVALUE 0520 80 DUP1 0521 15 ISZERO 0522 61 PUSH2 0x052a 0525 57 *JUMPI // Stack delta = +1 // Outputs[1] { @051F stack[0] = msg.value } // Block ends with conditional jump to 0x052a, if !msg.value label_0526: // Incoming jump from 0x0525, if not !msg.value // Inputs[1] { @0529 memory[0x00:0x00] } 0526 60 PUSH1 0x00 0528 80 DUP1 0529 FD *REVERT // Stack delta = +0 // Outputs[1] { @0529 revert(memory[0x00:0x00]); } // Block terminates label_052A: // Incoming jump from 0x0525, if !msg.value 052A 5B JUMPDEST 052B 50 POP 052C 61 PUSH2 0x0533 052F 61 PUSH2 0x0cd7 0532 56 *JUMP // Stack delta = +0 // Outputs[1] { @052C stack[-1] = 0x0533 } // Block ends with call to 0x0cd7, returns to 0x0533 label_0533: // Incoming return from call to 0x0CD7 at 0x0532 // Inputs[2] // { // @0536 memory[0x40:0x60] // @053A stack[-1] // } 0533 5B JUMPDEST 0534 60 PUSH1 0x40 0536 51 MLOAD 0537 61 PUSH2 0x0540 053A 91 SWAP2 053B 90 SWAP1 053C 61 PUSH2 0x2170 053F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @053A stack[-1] = 0x0540 // @053B stack[1] = memory[0x40:0x60] // @053B stack[0] = stack[-1] // } // Block ends with call to 0x2170, returns to 0x0540 label_0540: // Incoming return from call to 0x2170 at 0x053F // Inputs[3] // { // @0543 memory[0x40:0x60] // @0545 stack[-1] // @0548 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0540 5B JUMPDEST 0541 60 PUSH1 0x40 0543 51 MLOAD 0544 80 DUP1 0545 91 SWAP2 0546 03 SUB 0547 90 SWAP1 0548 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0548 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0549: // Incoming call from 0x0159, returns to 0x015A // Inputs[2] // { // @054C storage[0x10] // @054D stack[-1] // } 0549 5B JUMPDEST 054A 60 PUSH1 0x10 054C 54 SLOAD 054D 81 DUP2 054E 56 *JUMP // Stack delta = +1 // Outputs[1] { @054C stack[0] = storage[0x10] } // Block ends with unconditional jump to stack[-1] label_054F: // Incoming call from 0x0184, returns to 0x0185 // Inputs[2] // { // @0554 memory[0x40:0x60] // @058A stack[-1] // } 054F 5B JUMPDEST 0550 60 PUSH1 0x60 0552 60 PUSH1 0x40 0554 51 MLOAD 0555 80 DUP1 0556 60 PUSH1 0x40 0558 01 ADD 0559 60 PUSH1 0x40 055B 52 MSTORE 055C 80 DUP1 055D 60 PUSH1 0x11 055F 81 DUP2 0560 52 MSTORE 0561 60 PUSH1 0x20 0563 01 ADD 0564 7F PUSH32 0x4c696768746e696e67204e6574776f726b000000000000000000000000000000 0585 81 DUP2 0586 52 MSTORE 0587 50 POP 0588 90 SWAP1 0589 50 POP 058A 90 SWAP1 058B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @055B memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0560 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x11 // @0586 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x4c696768746e696e67204e6574776f726b000000000000000000000000000000 // @058A stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_058C: // Incoming jump from 0x01C1 // Incoming call from 0x09F0, returns to 0x09F1 // Inputs[7] // { // @058F stack[-1] // @0594 msg.sender // @05CE memory[0x00:0x40] // @05D1 stack[-2] // @060B memory[0x00:0x40] // @0627 msg.sender // @0662 memory[0x40:0x60] // } 058C 5B JUMPDEST 058D 60 PUSH1 0x00 058F 81 DUP2 0590 60 PUSH1 0x06 0592 60 PUSH1 0x00 0594 33 CALLER 0595 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05AA 16 AND 05AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05C0 16 AND 05C1 81 DUP2 05C2 52 MSTORE 05C3 60 PUSH1 0x20 05C5 01 ADD 05C6 90 SWAP1 05C7 81 DUP2 05C8 52 MSTORE 05C9 60 PUSH1 0x20 05CB 01 ADD 05CC 60 PUSH1 0x00 05CE 20 SHA3 05CF 60 PUSH1 0x00 05D1 85 DUP6 05D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05E7 16 AND 05E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05FD 16 AND 05FE 81 DUP2 05FF 52 MSTORE 0600 60 PUSH1 0x20 0602 01 ADD 0603 90 SWAP1 0604 81 DUP2 0605 52 MSTORE 0606 60 PUSH1 0x20 0608 01 ADD 0609 60 PUSH1 0x00 060B 20 SHA3 060C 81 DUP2 060D 90 SWAP1 060E 55 SSTORE 060F 50 POP 0610 82 DUP3 0611 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0626 16 AND 0627 33 CALLER 0628 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 063D 16 AND 063E 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 065F 84 DUP5 0660 60 PUSH1 0x40 0662 51 MLOAD 0663 61 PUSH2 0x066c 0666 91 SWAP2 0667 90 SWAP1 0668 61 PUSH2 0x224d 066B 56 *JUMP // Stack delta = +7 // Outputs[12] // { // @058D stack[0] = 0x00 // @05C2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @05C8 memory[0x20:0x40] = 0x06 // @05FF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0605 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @060E storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0626 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @063D stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @063E stack[3] = 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 // @0666 stack[4] = 0x066c // @0667 stack[5] = stack[-1] // @0667 stack[6] = memory[0x40:0x60] // } // Block ends with call to 0x224d, returns to 0x066C label_066C: // Incoming return from call to 0x224D at 0x066B // Inputs[9] // { // @066F memory[0x40:0x60] // @0671 stack[-1] // @0674 stack[-4] // @0674 stack[-3] // @0674 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0674 stack[-2] // @0677 stack[-5] // @0679 stack[-8] // @067A stack[-7] // } 066C 5B JUMPDEST 066D 60 PUSH1 0x40 066F 51 MLOAD 0670 80 DUP1 0671 91 SWAP2 0672 03 SUB 0673 90 SWAP1 0674 A3 LOG3 0675 60 PUSH1 0x01 0677 90 SWAP1 0678 50 POP 0679 92 SWAP3 067A 91 SWAP2 067B 50 POP 067C 50 POP 067D 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @0674 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); // @0679 stack[-8] = 0x01 // } // Block ends with unconditional jump to stack[-8] label_067E: // Incoming call from 0x01EC, returns to 0x01ED // Inputs[2] // { // @0683 storage[0x03] // @0686 stack[-1] // } 067E 5B JUMPDEST 067F 60 PUSH1 0x00 0681 60 PUSH1 0x03 0683 54 SLOAD 0684 90 SWAP1 0685 50 POP 0686 90 SWAP1 0687 56 *JUMP // Stack delta = +0 // Outputs[1] { @0686 stack[-1] = storage[0x03] } // Block ends with unconditional jump to stack[-1] label_0688: // Incoming jump from 0x0229 // Inputs[5] // { // @06B0 stack[-3] // @06EA memory[0x00:0x40] // @06ED msg.sender // @0727 memory[0x00:0x40] // @0728 storage[keccak256(memory[0x00:0x40])] // } 0688 5B JUMPDEST 0689 60 PUSH1 0x00 068B 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 06AC 60 PUSH1 0x06 06AE 60 PUSH1 0x00 06B0 86 DUP7 06B1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06C6 16 AND 06C7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06DC 16 AND 06DD 81 DUP2 06DE 52 MSTORE 06DF 60 PUSH1 0x20 06E1 01 ADD 06E2 90 SWAP1 06E3 81 DUP2 06E4 52 MSTORE 06E5 60 PUSH1 0x20 06E7 01 ADD 06E8 60 PUSH1 0x00 06EA 20 SHA3 06EB 60 PUSH1 0x00 06ED 33 CALLER 06EE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0703 16 AND 0704 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0719 16 AND 071A 81 DUP2 071B 52 MSTORE 071C 60 PUSH1 0x20 071E 01 ADD 071F 90 SWAP1 0720 81 DUP2 0721 52 MSTORE 0722 60 PUSH1 0x20 0724 01 ADD 0725 60 PUSH1 0x00 0727 20 SHA3 0728 54 SLOAD 0729 14 EQ 072A 61 PUSH2 0x0874 072D 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0689 stack[0] = 0x00 // @06DE memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @06E4 memory[0x20:0x40] = 0x06 // @071B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0721 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0874, if storage[keccak256(memory[0x00:0x40])] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff label_072E: // Incoming jump from 0x072D, if not storage[keccak256(memory[0x00:0x40])] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // Inputs[7] // { // @0731 stack[-2] // @0734 memory[0x40:0x60] // @076C stack[-4] // @07A6 memory[0x00:0x40] // @07A9 msg.sender // @07E3 memory[0x00:0x40] // @07E4 storage[keccak256(memory[0x00:0x40])] // } 072E 61 PUSH2 0x07f3 0731 82 DUP3 0732 60 PUSH1 0x40 0734 51 MLOAD 0735 80 DUP1 0736 60 PUSH1 0x40 0738 01 ADD 0739 60 PUSH1 0x40 073B 52 MSTORE 073C 80 DUP1 073D 60 PUSH1 0x16 073F 81 DUP2 0740 52 MSTORE 0741 60 PUSH1 0x20 0743 01 ADD 0744 7F PUSH32 0x496e73756666696369656e7420416c6c6f77616e636500000000000000000000 0765 81 DUP2 0766 52 MSTORE 0767 50 POP 0768 60 PUSH1 0x06 076A 60 PUSH1 0x00 076C 88 DUP9 076D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0782 16 AND 0783 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0798 16 AND 0799 81 DUP2 079A 52 MSTORE 079B 60 PUSH1 0x20 079D 01 ADD 079E 90 SWAP1 079F 81 DUP2 07A0 52 MSTORE 07A1 60 PUSH1 0x20 07A3 01 ADD 07A4 60 PUSH1 0x00 07A6 20 SHA3 07A7 60 PUSH1 0x00 07A9 33 CALLER 07AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07BF 16 AND 07C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07D5 16 AND 07D6 81 DUP2 07D7 52 MSTORE 07D8 60 PUSH1 0x20 07DA 01 ADD 07DB 90 SWAP1 07DC 81 DUP2 07DD 52 MSTORE 07DE 60 PUSH1 0x20 07E0 01 ADD 07E1 60 PUSH1 0x00 07E3 20 SHA3 07E4 54 SLOAD 07E5 61 PUSH2 0x0cfd 07E8 90 SWAP1 07E9 92 SWAP3 07EA 91 SWAP2 07EB 90 SWAP1 07EC 63 PUSH4 0xffffffff 07F1 16 AND 07F2 56 *JUMP // Stack delta = +4 // Outputs[11] // { // @072E stack[0] = 0x07f3 // @073B memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0740 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x16 // @0766 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x496e73756666696369656e7420416c6c6f77616e636500000000000000000000 // @079A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @07A0 memory[0x20:0x40] = 0x06 // @07D7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @07DD memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @07E9 stack[1] = storage[keccak256(memory[0x00:0x40])] // @07EA stack[2] = stack[-2] // @07EB stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x0cfd, returns to 0x07F3 label_07F3: // Incoming return from call to 0x0CFD at 0x07F2 // Inputs[5] // { // @07F8 stack[-5] // @0832 memory[0x00:0x40] // @0835 msg.sender // @086F memory[0x00:0x40] // @0870 stack[-1] // } 07F3 5B JUMPDEST 07F4 60 PUSH1 0x06 07F6 60 PUSH1 0x00 07F8 86 DUP7 07F9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 080E 16 AND 080F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0824 16 AND 0825 81 DUP2 0826 52 MSTORE 0827 60 PUSH1 0x20 0829 01 ADD 082A 90 SWAP1 082B 81 DUP2 082C 52 MSTORE 082D 60 PUSH1 0x20 082F 01 ADD 0830 60 PUSH1 0x00 0832 20 SHA3 0833 60 PUSH1 0x00 0835 33 CALLER 0836 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 084B 16 AND 084C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0861 16 AND 0862 81 DUP2 0863 52 MSTORE 0864 60 PUSH1 0x20 0866 01 ADD 0867 90 SWAP1 0868 81 DUP2 0869 52 MSTORE 086A 60 PUSH1 0x20 086C 01 ADD 086D 60 PUSH1 0x00 086F 20 SHA3 0870 81 DUP2 0871 90 SWAP1 0872 55 SSTORE 0873 50 POP // Stack delta = -1 // Outputs[5] // { // @0826 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @082C memory[0x20:0x40] = 0x06 // @0863 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0869 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0872 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block continues label_0874: // Incoming jump from 0x072D, if storage[keccak256(memory[0x00:0x40])] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // Incoming jump from 0x0873 // Inputs[3] // { // @0878 stack[-4] // @0879 stack[-3] // @087A stack[-2] // } 0874 5B JUMPDEST 0875 61 PUSH2 0x087f 0878 84 DUP5 0879 84 DUP5 087A 84 DUP5 087B 61 PUSH2 0x0d61 087E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0875 stack[0] = 0x087f // @0878 stack[1] = stack[-4] // @0879 stack[2] = stack[-3] // @087A stack[3] = stack[-2] // } // Block ends with call to 0x0d61, returns to 0x087F label_087F: // Incoming return from call to 0x0D61 at 0x087E // Incoming return from call to 0x0D61 at 0x087E // Inputs[4] // { // @0880 stack[-1] // @0880 stack[-2] // @0882 stack[-6] // @0883 stack[-5] // } 087F 5B JUMPDEST 0880 90 SWAP1 0881 50 POP 0882 93 SWAP4 0883 92 SWAP3 0884 50 POP 0885 50 POP 0886 50 POP 0887 56 *JUMP // Stack delta = -5 // Outputs[1] { @0882 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0888: // Incoming call from 0x095D, returns to 0x095E // Incoming call from 0x0A62, returns to 0x0A63 // Incoming call from 0x0C73, returns to 0x0C74 // Incoming jump from 0x0266 // Inputs[3] // { // @088F storage[0x00] // @08C3 stack[-1] // @08DD stack[-2] // } 0888 5B JUMPDEST 0889 60 PUSH1 0x00 088B 80 DUP1 088C 60 PUSH1 0x00 088E 90 SWAP1 088F 54 SLOAD 0890 90 SWAP1 0891 61 PUSH2 0x0100 0894 0A EXP 0895 90 SWAP1 0896 04 DIV 0897 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08AC 16 AND 08AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08C2 16 AND 08C3 82 DUP3 08C4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08D9 16 AND 08DA 14 EQ 08DB 90 SWAP1 08DC 50 POP 08DD 91 SWAP2 08DE 90 SWAP1 08DF 50 POP 08E0 56 *JUMP // Stack delta = -1 // Outputs[1] { @08DD stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-2] label_08E1: // Incoming call from 0x0291, returns to 0x0292 // Inputs[1] { @08E8 stack[-1] } 08E1 5B JUMPDEST 08E2 60 PUSH1 0x00 08E4 60 PUSH1 0x09 08E6 90 SWAP1 08E7 50 POP 08E8 90 SWAP1 08E9 56 *JUMP // Stack delta = +0 // Outputs[1] { @08E8 stack[-1] = 0x09 } // Block ends with unconditional jump to stack[-1] label_08EA: // Incoming call from 0x02BC, returns to 0x02BD // Inputs[7] // { // @08F0 storage[0x0d] // @0927 address(this).balance // @0927 address(this) // @092F memory[0x40:0x60] // @0934 memory[0x40:0x60] // @093C memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @093C address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } 08EA 5B JUMPDEST 08EB 60 PUSH1 0x0d 08ED 60 PUSH1 0x00 08EF 90 SWAP1 08F0 54 SLOAD 08F1 90 SWAP1 08F2 61 PUSH2 0x0100 08F5 0A EXP 08F6 90 SWAP1 08F7 04 DIV 08F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 090D 16 AND 090E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0923 16 AND 0924 61 PUSH2 0x08fc 0927 47 SELFBALANCE 0928 90 SWAP1 0929 81 DUP2 092A 15 ISZERO 092B 02 MUL 092C 90 SWAP1 092D 60 PUSH1 0x40 092F 51 MLOAD 0930 60 PUSH1 0x00 0932 60 PUSH1 0x40 0934 51 MLOAD 0935 80 DUP1 0936 83 DUP4 0937 03 SUB 0938 81 DUP2 0939 85 DUP6 093A 88 DUP9 093B 88 DUP9 093C F1 CALL 093D 93 SWAP4 093E 50 POP 093F 50 POP 0940 50 POP 0941 50 POP 0942 15 ISZERO 0943 80 DUP1 0944 15 ISZERO 0945 61 PUSH2 0x0952 0948 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @093C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0942 stack[0] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0952, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_0949: // Incoming jump from 0x0948, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[4] // { // @0949 returndata.length // @094D returndata[0x00:0x00 + returndata.length] // @094E returndata.length // @0951 memory[0x00:0x00 + returndata.length] // } 0949 3D RETURNDATASIZE 094A 60 PUSH1 0x00 094C 80 DUP1 094D 3E RETURNDATACOPY 094E 3D RETURNDATASIZE 094F 60 PUSH1 0x00 0951 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @094D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0951 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0952: // Incoming jump from 0x0948, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @0954 stack[-2] } 0952 5B JUMPDEST 0953 50 POP 0954 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0955: // Incoming jump from 0x02E5 // Inputs[1] { @0959 msg.sender } 0955 5B JUMPDEST 0956 61 PUSH2 0x095e 0959 33 CALLER 095A 61 PUSH2 0x0888 095D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0956 stack[0] = 0x095e // @0959 stack[1] = msg.sender // } // Block ends with call to 0x0888, returns to 0x095E label_095E: // Incoming return from call to 0x0888 at 0x095D // Inputs[1] { @0962 stack[-1] } 095E 5B JUMPDEST 095F 61 PUSH2 0x099d 0962 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x099d, if stack[-1] label_0963: // Incoming jump from 0x0962, if not stack[-1] // Inputs[1] { @0965 memory[0x40:0x60] } 0963 60 PUSH1 0x40 0965 51 MLOAD 0966 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0987 81 DUP2 0988 52 MSTORE 0989 60 PUSH1 0x04 098B 01 ADD 098C 61 PUSH2 0x0994 098F 90 SWAP1 0990 61 PUSH2 0x222d 0993 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0988 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @098F stack[0] = 0x0994 // @098F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x222d, returns to 0x0994 label_0994: // Incoming return from call to 0x222D at 0x0993 // Inputs[3] // { // @0997 memory[0x40:0x60] // @0999 stack[-1] // @099C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0994 5B JUMPDEST 0995 60 PUSH1 0x40 0997 51 MLOAD 0998 80 DUP1 0999 91 SWAP2 099A 03 SUB 099B 90 SWAP1 099C FD *REVERT // Stack delta = -1 // Outputs[1] { @099C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_099D: // Incoming jump from 0x0962, if stack[-1] // Inputs[4] // { // @099E stack[-2] // @09A5 stack[-1] // @09AE storage[0x0a] // @09B1 storage[0x09] // } 099D 5B JUMPDEST 099E 81 DUP2 099F 60 PUSH1 0x09 09A1 81 DUP2 09A2 90 SWAP1 09A3 55 SSTORE 09A4 50 POP 09A5 80 DUP1 09A6 60 PUSH1 0x0a 09A8 81 DUP2 09A9 90 SWAP1 09AA 55 SSTORE 09AB 50 POP 09AC 60 PUSH1 0x0a 09AE 54 SLOAD 09AF 60 PUSH1 0x09 09B1 54 SLOAD 09B2 61 PUSH2 0x09bb 09B5 91 SWAP2 09B6 90 SWAP1 09B7 61 PUSH2 0x2366 09BA 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @09A3 storage[0x09] = stack[-2] // @09AA storage[0x0a] = stack[-1] // @09B5 stack[0] = 0x09bb // @09B6 stack[1] = storage[0x0a] // @09B6 stack[2] = storage[0x09] // } // Block ends with call to 0x2366, returns to 0x09BB label_09BB: // Incoming return from call to 0x2366 at 0x09BA // Inputs[2] // { // @09BE stack[-1] // @09C4 stack[-4] // } 09BB 5B JUMPDEST 09BC 60 PUSH1 0x0b 09BE 81 DUP2 09BF 90 SWAP1 09C0 55 SSTORE 09C1 50 POP 09C2 50 POP 09C3 50 POP 09C4 56 *JUMP // Stack delta = -4 // Outputs[1] { @09C0 storage[0x0b] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_09C5: // Incoming jump from 0x030E // Inputs[1] { @09CB stack[-1] } 09C5 5B JUMPDEST 09C6 60 PUSH1 0x00 09C8 61 PUSH2 0x09f1 09CB 82 DUP3 09CC 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 09ED 61 PUSH2 0x058c 09F0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09C6 stack[0] = 0x00 // @09C8 stack[1] = 0x09f1 // @09CB stack[2] = stack[-1] // @09CC stack[3] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // } // Block ends with call to 0x058c, returns to 0x09F1 label_09F1: // Incoming return from call to 0x058C at 0x09F0 // Inputs[4] // { // @09F2 stack[-1] // @09F2 stack[-2] // @09F4 stack[-4] // @09F5 stack[-3] // } 09F1 5B JUMPDEST 09F2 90 SWAP1 09F3 50 POP 09F4 91 SWAP2 09F5 90 SWAP1 09F6 50 POP 09F7 56 *JUMP // Stack delta = -3 // Outputs[1] { @09F4 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_09F8: // Incoming call from 0x0339, returns to 0x033A // Inputs[2] // { // @09FB storage[0x04] // @09FC stack[-1] // } 09F8 5B JUMPDEST 09F9 60 PUSH1 0x04 09FB 54 SLOAD 09FC 81 DUP2 09FD 56 *JUMP // Stack delta = +1 // Outputs[1] { @09FB stack[0] = storage[0x04] } // Block ends with unconditional jump to stack[-1] label_09FE: // Incoming call from 0x0364, returns to 0x0365 // Inputs[2] // { // @0A04 storage[0x0f] // @0A0F stack[-1] // } 09FE 5B JUMPDEST 09FF 60 PUSH1 0x0f 0A01 60 PUSH1 0x14 0A03 90 SWAP1 0A04 54 SLOAD 0A05 90 SWAP1 0A06 61 PUSH2 0x0100 0A09 0A EXP 0A0A 90 SWAP1 0A0B 04 DIV 0A0C 60 PUSH1 0xff 0A0E 16 AND 0A0F 81 DUP2 0A10 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A0E stack[0] = 0xff & storage[0x0f] / 0x0100 ** 0x14 } // Block ends with unconditional jump to stack[-1] label_0A11: // Incoming jump from 0x03A1 // Inputs[4] // { // @0A18 stack[-1] // @0A52 memory[0x00:0x40] // @0A53 storage[keccak256(memory[0x00:0x40])] // @0A56 stack[-2] // } 0A11 5B JUMPDEST 0A12 60 PUSH1 0x00 0A14 60 PUSH1 0x05 0A16 60 PUSH1 0x00 0A18 83 DUP4 0A19 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A2E 16 AND 0A2F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A44 16 AND 0A45 81 DUP2 0A46 52 MSTORE 0A47 60 PUSH1 0x20 0A49 01 ADD 0A4A 90 SWAP1 0A4B 81 DUP2 0A4C 52 MSTORE 0A4D 60 PUSH1 0x20 0A4F 01 ADD 0A50 60 PUSH1 0x00 0A52 20 SHA3 0A53 54 SLOAD 0A54 90 SWAP1 0A55 50 POP 0A56 91 SWAP2 0A57 90 SWAP1 0A58 50 POP 0A59 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0A46 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0A4C memory[0x20:0x40] = 0x05 // @0A56 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0A5A: // Incoming call from 0x03CC, returns to 0x03CD // Inputs[1] { @0A5E msg.sender } 0A5A 5B JUMPDEST 0A5B 61 PUSH2 0x0a63 0A5E 33 CALLER 0A5F 61 PUSH2 0x0888 0A62 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A5B stack[0] = 0x0a63 // @0A5E stack[1] = msg.sender // } // Block ends with call to 0x0888, returns to 0x0A63 label_0A63: // Incoming return from call to 0x0888 at 0x0A62 // Inputs[1] { @0A67 stack[-1] } 0A63 5B JUMPDEST 0A64 61 PUSH2 0x0aa2 0A67 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0aa2, if stack[-1] label_0A68: // Incoming jump from 0x0A67, if not stack[-1] // Inputs[1] { @0A6A memory[0x40:0x60] } 0A68 60 PUSH1 0x40 0A6A 51 MLOAD 0A6B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A8C 81 DUP2 0A8D 52 MSTORE 0A8E 60 PUSH1 0x04 0A90 01 ADD 0A91 61 PUSH2 0x0a99 0A94 90 SWAP1 0A95 61 PUSH2 0x222d 0A98 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A8D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A94 stack[0] = 0x0a99 // @0A94 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x222d, returns to 0x0A99 label_0A99: // Incoming return from call to 0x222D at 0x0A98 // Inputs[3] // { // @0A9C memory[0x40:0x60] // @0A9E stack[-1] // @0AA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0A99 5B JUMPDEST 0A9A 60 PUSH1 0x40 0A9C 51 MLOAD 0A9D 80 DUP1 0A9E 91 SWAP2 0A9F 03 SUB 0AA0 90 SWAP1 0AA1 FD *REVERT // Stack delta = -1 // Outputs[1] { @0AA1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0AA2: // Incoming jump from 0x0A67, if stack[-1] // Inputs[2] // { // @0AAD storage[0x00] // @0B09 memory[0x40:0x60] // } 0AA2 5B JUMPDEST 0AA3 60 PUSH1 0x00 0AA5 80 DUP1 0AA6 60 PUSH1 0x00 0AA8 61 PUSH2 0x0100 0AAB 0A EXP 0AAC 81 DUP2 0AAD 54 SLOAD 0AAE 81 DUP2 0AAF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AC4 02 MUL 0AC5 19 NOT 0AC6 16 AND 0AC7 90 SWAP1 0AC8 83 DUP4 0AC9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ADE 16 AND 0ADF 02 MUL 0AE0 17 OR 0AE1 90 SWAP1 0AE2 55 SSTORE 0AE3 50 POP 0AE4 7F PUSH32 0x04dba622d284ed0014ee4b9a6a68386be1a4c08a4913ae272de89199cc686163 0B05 60 PUSH1 0x00 0B07 60 PUSH1 0x40 0B09 51 MLOAD 0B0A 61 PUSH2 0x0b13 0B0D 91 SWAP2 0B0E 90 SWAP1 0B0F 61 PUSH2 0x20d9 0B12 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0AE2 storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00]) // @0AE4 stack[0] = 0x04dba622d284ed0014ee4b9a6a68386be1a4c08a4913ae272de89199cc686163 // @0B0D stack[1] = 0x0b13 // @0B0E stack[2] = 0x00 // @0B0E stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x20d9, returns to 0x0B13 label_0B13: // Incoming return from call to 0x20D9 at 0x0B12 // Inputs[5] // { // @0B16 memory[0x40:0x60] // @0B18 stack[-1] // @0B1B stack[-2] // @0B1B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0B1C stack[-3] // } 0B13 5B JUMPDEST 0B14 60 PUSH1 0x40 0B16 51 MLOAD 0B17 80 DUP1 0B18 91 SWAP2 0B19 03 SUB 0B1A 90 SWAP1 0B1B A1 LOG1 0B1C 56 *JUMP // Stack delta = -3 // Outputs[1] { @0B1B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2]]); } // Block ends with unconditional jump to stack[-3] label_0B1D: // Incoming call from 0x03E3, returns to 0x03E4 // Inputs[2] // { // @0B24 storage[0x00] // @0B44 stack[-1] // } 0B1D 5B JUMPDEST 0B1E 60 PUSH1 0x00 0B20 80 DUP1 0B21 60 PUSH1 0x00 0B23 90 SWAP1 0B24 54 SLOAD 0B25 90 SWAP1 0B26 61 PUSH2 0x0100 0B29 0A EXP 0B2A 90 SWAP1 0B2B 04 DIV 0B2C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B41 16 AND 0B42 90 SWAP1 0B43 50 POP 0B44 90 SWAP1 0B45 56 *JUMP // Stack delta = +0 // Outputs[1] { @0B44 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0B46: // Incoming call from 0x040E, returns to 0x040F // Inputs[2] // { // @0B4B memory[0x40:0x60] // @0B81 stack[-1] // } 0B46 5B JUMPDEST 0B47 60 PUSH1 0x60 0B49 60 PUSH1 0x40 0B4B 51 MLOAD 0B4C 80 DUP1 0B4D 60 PUSH1 0x40 0B4F 01 ADD 0B50 60 PUSH1 0x40 0B52 52 MSTORE 0B53 80 DUP1 0B54 60 PUSH1 0x08 0B56 81 DUP2 0B57 52 MSTORE 0B58 60 PUSH1 0x20 0B5A 01 ADD 0B5B 7F PUSH32 0xf09f97b2204e4554000000000000000000000000000000000000000000000000 0B7C 81 DUP2 0B7D 52 MSTORE 0B7E 50 POP 0B7F 90 SWAP1 0B80 50 POP 0B81 90 SWAP1 0B82 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0B52 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0B57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08 // @0B7D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xf09f97b2204e4554000000000000000000000000000000000000000000000000 // @0B81 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_0B83: // Incoming call from 0x0439, returns to 0x043A // Inputs[2] // { // @0B89 storage[0x0f] // @0BA7 stack[-1] // } 0B83 5B JUMPDEST 0B84 60 PUSH1 0x0f 0B86 60 PUSH1 0x00 0B88 90 SWAP1 0B89 54 SLOAD 0B8A 90 SWAP1 0B8B 61 PUSH2 0x0100 0B8E 0A EXP 0B8F 90 SWAP1 0B90 04 DIV 0B91 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BA6 16 AND 0BA7 81 DUP2 0BA8 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BA6 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0BA9: // Incoming jump from 0x0476 // Inputs[3] // { // @0BAF msg.sender // @0BB0 stack[-2] // @0BB1 stack[-1] // } 0BA9 5B JUMPDEST 0BAA 60 PUSH1 0x00 0BAC 61 PUSH2 0x0bb6 0BAF 33 CALLER 0BB0 84 DUP5 0BB1 84 DUP5 0BB2 61 PUSH2 0x0d61 0BB5 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0BAA stack[0] = 0x00 // @0BAC stack[1] = 0x0bb6 // @0BAF stack[2] = msg.sender // @0BB0 stack[3] = stack[-2] // @0BB1 stack[4] = stack[-1] // } // Block ends with call to 0x0d61, returns to 0x0BB6 label_0BB6: // Incoming return from call to 0x0D61 at 0x0BB5 // Incoming return from call to 0x0D61 at 0x0BB5 // Inputs[4] // { // @0BB7 stack[-1] // @0BB7 stack[-2] // @0BB9 stack[-5] // @0BBA stack[-4] // } 0BB6 5B JUMPDEST 0BB7 90 SWAP1 0BB8 50 POP 0BB9 92 SWAP3 0BBA 91 SWAP2 0BBB 50 POP 0BBC 50 POP 0BBD 56 *JUMP // Stack delta = -4 // Outputs[1] { @0BB9 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0BBE: // Incoming jump from 0x04B3 // Inputs[6] // { // @0BC5 stack[-2] // @0BFF memory[0x00:0x40] // @0C02 stack[-1] // @0C3C memory[0x00:0x40] // @0C3D storage[keccak256(memory[0x00:0x40])] // @0C40 stack[-3] // } 0BBE 5B JUMPDEST 0BBF 60 PUSH1 0x00 0BC1 60 PUSH1 0x06 0BC3 60 PUSH1 0x00 0BC5 84 DUP5 0BC6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BDB 16 AND 0BDC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BF1 16 AND 0BF2 81 DUP2 0BF3 52 MSTORE 0BF4 60 PUSH1 0x20 0BF6 01 ADD 0BF7 90 SWAP1 0BF8 81 DUP2 0BF9 52 MSTORE 0BFA 60 PUSH1 0x20 0BFC 01 ADD 0BFD 60 PUSH1 0x00 0BFF 20 SHA3 0C00 60 PUSH1 0x00 0C02 83 DUP4 0C03 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C18 16 AND 0C19 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C2E 16 AND 0C2F 81 DUP2 0C30 52 MSTORE 0C31 60 PUSH1 0x20 0C33 01 ADD 0C34 90 SWAP1 0C35 81 DUP2 0C36 52 MSTORE 0C37 60 PUSH1 0x20 0C39 01 ADD 0C3A 60 PUSH1 0x00 0C3C 20 SHA3 0C3D 54 SLOAD 0C3E 90 SWAP1 0C3F 50 POP 0C40 92 SWAP3 0C41 91 SWAP2 0C42 50 POP 0C43 50 POP 0C44 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0BF3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0BF9 memory[0x20:0x40] = 0x06 // @0C30 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0C36 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0C40 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0C45: // Incoming call from 0x04DE, returns to 0x04DF // Inputs[2] // { // @0C4B storage[0x0d] // @0C69 stack[-1] // } 0C45 5B JUMPDEST 0C46 60 PUSH1 0x0d 0C48 60 PUSH1 0x00 0C4A 90 SWAP1 0C4B 54 SLOAD 0C4C 90 SWAP1 0C4D 61 PUSH2 0x0100 0C50 0A EXP 0C51 90 SWAP1 0C52 04 DIV 0C53 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C68 16 AND 0C69 81 DUP2 0C6A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C68 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0C6B: // Incoming jump from 0x051B // Inputs[1] { @0C6F msg.sender } 0C6B 5B JUMPDEST 0C6C 61 PUSH2 0x0c74 0C6F 33 CALLER 0C70 61 PUSH2 0x0888 0C73 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C6C stack[0] = 0x0c74 // @0C6F stack[1] = msg.sender // } // Block ends with call to 0x0888, returns to 0x0C74 label_0C74: // Incoming return from call to 0x0888 at 0x0C73 // Inputs[1] { @0C78 stack[-1] } 0C74 5B JUMPDEST 0C75 61 PUSH2 0x0cb3 0C78 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0cb3, if stack[-1] label_0C79: // Incoming jump from 0x0C78, if not stack[-1] // Inputs[1] { @0C7B memory[0x40:0x60] } 0C79 60 PUSH1 0x40 0C7B 51 MLOAD 0C7C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0C9D 81 DUP2 0C9E 52 MSTORE 0C9F 60 PUSH1 0x04 0CA1 01 ADD 0CA2 61 PUSH2 0x0caa 0CA5 90 SWAP1 0CA6 61 PUSH2 0x222d 0CA9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C9E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0CA5 stack[0] = 0x0caa // @0CA5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x222d, returns to 0x0CAA label_0CAA: // Incoming return from call to 0x222D at 0x0CA9 // Inputs[3] // { // @0CAD memory[0x40:0x60] // @0CAF stack[-1] // @0CB2 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0CAA 5B JUMPDEST 0CAB 60 PUSH1 0x40 0CAD 51 MLOAD 0CAE 80 DUP1 0CAF 91 SWAP2 0CB0 03 SUB 0CB1 90 SWAP1 0CB2 FD *REVERT // Stack delta = -1 // Outputs[1] { @0CB2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0CB3: // Incoming jump from 0x0C78, if stack[-1] // Inputs[2] // { // @0CB7 stack[-1] // @0CBA storage[0x03] // } 0CB3 5B JUMPDEST 0CB4 61 PUSH2 0x03e8 0CB7 81 DUP2 0CB8 60 PUSH1 0x03 0CBA 54 SLOAD 0CBB 61 PUSH2 0x0cc4 0CBE 91 SWAP2 0CBF 90 SWAP1 0CC0 61 PUSH2 0x23ed 0CC3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CB4 stack[0] = 0x03e8 // @0CBE stack[1] = 0x0cc4 // @0CBF stack[2] = stack[-1] // @0CBF stack[3] = storage[0x03] // } // Block ends with call to 0x23ed, returns to 0x0CC4 label_0CC4: // Incoming return from call to 0x23ED at 0x0CC3 // Inputs[2] // { // @0CC8 stack[-2] // @0CC9 stack[-1] // } 0CC4 5B JUMPDEST 0CC5 61 PUSH2 0x0cce 0CC8 91 SWAP2 0CC9 90 SWAP1 0CCA 61 PUSH2 0x23bc 0CCD 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0CC8 stack[-2] = 0x0cce // @0CC9 stack[-1] = stack[-2] // @0CC9 stack[0] = stack[-1] // } // Block ends with call to 0x23bc, returns to 0x0CCE label_0CCE: // Incoming return from call to 0x23BC at 0x0CCD // Inputs[2] // { // @0CD1 stack[-1] // @0CD6 stack[-3] // } 0CCE 5B JUMPDEST 0CCF 60 PUSH1 0x04 0CD1 81 DUP2 0CD2 90 SWAP1 0CD3 55 SSTORE 0CD4 50 POP 0CD5 50 POP 0CD6 56 *JUMP // Stack delta = -3 // Outputs[1] { @0CD3 storage[0x04] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0CD7: // Incoming call from 0x0532, returns to 0x0533 // Inputs[2] // { // @0CDD storage[0x0e] // @0CFB stack[-1] // } 0CD7 5B JUMPDEST 0CD8 60 PUSH1 0x0e 0CDA 60 PUSH1 0x00 0CDC 90 SWAP1 0CDD 54 SLOAD 0CDE 90 SWAP1 0CDF 61 PUSH2 0x0100 0CE2 0A EXP 0CE3 90 SWAP1 0CE4 04 DIV 0CE5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CFA 16 AND 0CFB 81 DUP2 0CFC 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CFA stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0CFD: // Incoming call from 0x07F2, returns to 0x07F3 // Incoming call from 0x0FBD, returns to 0x0FBE // Incoming call from 0x1C2D, returns to 0x1C2E // Incoming call from 0x11B4, returns to 0x11B5 // Inputs[3] // { // @0D00 stack[-3] // @0D01 stack[-2] // @0D04 stack[-1] // } 0CFD 5B JUMPDEST 0CFE 60 PUSH1 0x00 0D00 83 DUP4 0D01 83 DUP4 0D02 11 GT 0D03 15 ISZERO 0D04 82 DUP3 0D05 90 SWAP1 0D06 61 PUSH2 0x0d45 0D09 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0CFE stack[0] = 0x00 // @0D05 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0d45, if !(stack[-2] > stack[-3]) label_0D0A: // Incoming jump from 0x0D09, if not !(stack[-2] > stack[-3]) // Inputs[2] // { // @0D0C memory[0x40:0x60] // @0D36 stack[-1] // } 0D0A 60 PUSH1 0x40 0D0C 51 MLOAD 0D0D 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0D2E 81 DUP2 0D2F 52 MSTORE 0D30 60 PUSH1 0x04 0D32 01 ADD 0D33 61 PUSH2 0x0d3c 0D36 91 SWAP2 0D37 90 SWAP1 0D38 61 PUSH2 0x218b 0D3B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0D2F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0D36 stack[-1] = 0x0d3c // @0D37 stack[1] = 0x04 + memory[0x40:0x60] // @0D37 stack[0] = stack[-1] // } // Block ends with call to 0x218b, returns to 0x0D3C label_0D3C: // Incoming return from call to 0x218B at 0x0D3B // Inputs[3] // { // @0D3F memory[0x40:0x60] // @0D41 stack[-1] // @0D44 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0D3C 5B JUMPDEST 0D3D 60 PUSH1 0x40 0D3F 51 MLOAD 0D40 80 DUP1 0D41 91 SWAP2 0D42 03 SUB 0D43 90 SWAP1 0D44 FD *REVERT // Stack delta = -1 // Outputs[1] { @0D44 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0D45: // Incoming jump from 0x0D09, if !(stack[-2] > stack[-3]) // Inputs[2] // { // @0D49 stack[-4] // @0D4A stack[-5] // } 0D45 5B JUMPDEST 0D46 50 POP 0D47 60 PUSH1 0x00 0D49 83 DUP4 0D4A 85 DUP6 0D4B 61 PUSH2 0x0d54 0D4E 91 SWAP2 0D4F 90 SWAP1 0D50 61 PUSH2 0x2447 0D53 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0D47 stack[-1] = 0x00 // @0D4E stack[0] = 0x0d54 // @0D4F stack[2] = stack[-5] // @0D4F stack[1] = stack[-4] // } // Block ends with call to 0x2447, returns to 0x0D54 label_0D54: // Incoming return from call to 0x2447 at 0x0D53 // Inputs[5] // { // @0D55 stack[-1] // @0D55 stack[-2] // @0D58 stack[-3] // @0D5B stack[-7] // @0D5C stack[-6] // } 0D54 5B JUMPDEST 0D55 90 SWAP1 0D56 50 POP 0D57 80 DUP1 0D58 91 SWAP2 0D59 50 POP 0D5A 50 POP 0D5B 93 SWAP4 0D5C 92 SWAP3 0D5D 50 POP 0D5E 50 POP 0D5F 50 POP 0D60 56 *JUMP // Stack delta = -6 // Outputs[1] { @0D5B stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_0D61: // Incoming call from 0x087E, returns to 0x087F // Incoming call from 0x0BB5, returns to 0x0BB6 // Inputs[1] { @0D69 storage[0x11] } 0D61 5B JUMPDEST 0D62 60 PUSH1 0x00 0D64 60 PUSH1 0x11 0D66 60 PUSH1 0x00 0D68 90 SWAP1 0D69 54 SLOAD 0D6A 90 SWAP1 0D6B 61 PUSH2 0x0100 0D6E 0A EXP 0D6F 90 SWAP1 0D70 04 DIV 0D71 60 PUSH1 0xff 0D73 16 AND 0D74 15 ISZERO 0D75 61 PUSH2 0x0d8a 0D78 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D62 stack[0] = 0x00 } // Block ends with conditional jump to 0x0d8a, if !(0xff & storage[0x11] / 0x0100 ** 0x00) label_0D79: // Incoming jump from 0x0D78, if not !(0xff & storage[0x11] / 0x0100 ** 0x00) // Inputs[3] // { // @0D7C stack[-4] // @0D7D stack[-3] // @0D7E stack[-2] // } 0D79 61 PUSH2 0x0d83 0D7C 84 DUP5 0D7D 84 DUP5 0D7E 84 DUP5 0D7F 61 PUSH2 0x112a 0D82 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D79 stack[0] = 0x0d83 // @0D7C stack[1] = stack[-4] // @0D7D stack[2] = stack[-3] // @0D7E stack[3] = stack[-2] // } // Block ends with call to 0x112a, returns to 0x0D83 label_0D83: // Incoming return from call to 0x112A at 0x0D82 // Inputs[2] // { // @0D84 stack[-2] // @0D84 stack[-1] // } 0D83 5B JUMPDEST 0D84 90 SWAP1 0D85 50 POP 0D86 61 PUSH2 0x1123 0D89 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D84 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x1123 label_0D8A: // Incoming jump from 0x0D78, if !(0xff & storage[0x11] / 0x0100 ** 0x00) // Inputs[2] // { // @0D90 storage[0x0f] // @0DC4 stack[-3] // } 0D8A 5B JUMPDEST 0D8B 60 PUSH1 0x0f 0D8D 60 PUSH1 0x00 0D8F 90 SWAP1 0D90 54 SLOAD 0D91 90 SWAP1 0D92 61 PUSH2 0x0100 0D95 0A EXP 0D96 90 SWAP1 0D97 04 DIV 0D98 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DAD 16 AND 0DAE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DC3 16 AND 0DC4 83 DUP4 0DC5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DDA 16 AND 0DDB 14 EQ 0DDC 15 ISZERO 0DDD 80 DUP1 0DDE 15 ISZERO 0DDF 61 PUSH2 0x0e36 0DE2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DDC stack[0] = !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) } // Block ends with conditional jump to 0x0e36, if !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) label_0DE3: // Incoming jump from 0x0DE2, if not !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) // Inputs[2] // { // @0DE9 storage[0x02] // @0E1D stack[-4] // } 0DE3 50 POP 0DE4 60 PUSH1 0x02 0DE6 60 PUSH1 0x00 0DE8 90 SWAP1 0DE9 54 SLOAD 0DEA 90 SWAP1 0DEB 61 PUSH2 0x0100 0DEE 0A EXP 0DEF 90 SWAP1 0DF0 04 DIV 0DF1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E06 16 AND 0E07 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E1C 16 AND 0E1D 83 DUP4 0E1E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E33 16 AND 0E34 14 EQ 0E35 15 ISZERO 0E36 5B JUMPDEST 0E37 15 ISZERO 0E38 61 PUSH2 0x0f1f 0E3B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f1f, if !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00) label_0E3C: // Incoming jump from 0x0E3B, if not !stack[-1] // Incoming jump from 0x0E3B, if not !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00) // Inputs[3] // { // @0E40 stack[-3] // @0E7A memory[0x00:0x40] // @0E7E storage[keccak256(memory[0x00:0x40])] // } 0E3C 60 PUSH1 0x08 0E3E 60 PUSH1 0x00 0E40 84 DUP5 0E41 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E56 16 AND 0E57 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E6C 16 AND 0E6D 81 DUP2 0E6E 52 MSTORE 0E6F 60 PUSH1 0x20 0E71 01 ADD 0E72 90 SWAP1 0E73 81 DUP2 0E74 52 MSTORE 0E75 60 PUSH1 0x20 0E77 01 ADD 0E78 60 PUSH1 0x00 0E7A 20 SHA3 0E7B 60 PUSH1 0x00 0E7D 90 SWAP1 0E7E 54 SLOAD 0E7F 90 SWAP1 0E80 61 PUSH2 0x0100 0E83 0A EXP 0E84 90 SWAP1 0E85 04 DIV 0E86 60 PUSH1 0xff 0E88 16 AND 0E89 80 DUP1 0E8A 61 PUSH2 0x0edf 0E8D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0E6E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0E74 memory[0x20:0x40] = 0x08 // @0E88 stack[0] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with conditional jump to 0x0edf, if 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 label_0E8E: // Incoming jump from 0x0E8D, if not 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // Inputs[5] // { // @0E91 storage[0x04] // @0E92 stack[-3] // @0E97 stack[-4] // @0ED1 memory[0x00:0x40] // @0ED2 storage[keccak256(memory[0x00:0x40])] // } 0E8E 50 POP 0E8F 60 PUSH1 0x04 0E91 54 SLOAD 0E92 82 DUP3 0E93 60 PUSH1 0x05 0E95 60 PUSH1 0x00 0E97 86 DUP7 0E98 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EAD 16 AND 0EAE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EC3 16 AND 0EC4 81 DUP2 0EC5 52 MSTORE 0EC6 60 PUSH1 0x20 0EC8 01 ADD 0EC9 90 SWAP1 0ECA 81 DUP2 0ECB 52 MSTORE 0ECC 60 PUSH1 0x20 0ECE 01 ADD 0ECF 60 PUSH1 0x00 0ED1 20 SHA3 0ED2 54 SLOAD 0ED3 61 PUSH2 0x0edc 0ED6 91 SWAP2 0ED7 90 SWAP1 0ED8 61 PUSH2 0x2366 0EDB 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @0E91 stack[-1] = storage[0x04] // @0EC5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0ECB memory[0x20:0x40] = 0x05 // @0ED6 stack[0] = 0x0edc // @0ED7 stack[1] = stack[-3] // @0ED7 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2366, returns to 0x0EDC label_0EDC: // Incoming return from call to 0x2366 at 0x0EDB // Inputs[2] // { // @0EDD stack[-2] // @0EDD stack[-1] // } 0EDC 5B JUMPDEST 0EDD 11 GT 0EDE 15 ISZERO // Stack delta = -1 // Outputs[1] { @0EDE stack[-2] = !(stack[-1] > stack[-2]) } // Block continues label_0EDF: // Incoming jump from 0x0E8D, if 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // Incoming jump from 0x0EDE // Inputs[1] { @0EE3 stack[-1] } 0EDF 5B JUMPDEST 0EE0 61 PUSH2 0x0f1e 0EE3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f1e, if stack[-1] label_0EE4: // Incoming jump from 0x0EE3, if not stack[-1] // Inputs[1] { @0EE6 memory[0x40:0x60] } 0EE4 60 PUSH1 0x40 0EE6 51 MLOAD 0EE7 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0F08 81 DUP2 0F09 52 MSTORE 0F0A 60 PUSH1 0x04 0F0C 01 ADD 0F0D 61 PUSH2 0x0f15 0F10 90 SWAP1 0F11 61 PUSH2 0x21ad 0F14 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F09 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0F10 stack[0] = 0x0f15 // @0F10 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x21ad, returns to 0x0F15 label_0F15: // Incoming return from call to 0x21AD at 0x0F14 // Inputs[3] // { // @0F18 memory[0x40:0x60] // @0F1A stack[-1] // @0F1D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0F15 5B JUMPDEST 0F16 60 PUSH1 0x40 0F18 51 MLOAD 0F19 80 DUP1 0F1A 91 SWAP2 0F1B 03 SUB 0F1C 90 SWAP1 0F1D FD *REVERT // Stack delta = -1 // Outputs[1] { @0F1D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0F1E: // Incoming jump from 0x0EE3, if stack[-1] 0F1E 5B JUMPDEST // Stack delta = +0 // Block continues label_0F1F: // Incoming jump from 0x0E3B, if !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00) // Incoming jump from 0x0E3B, if !stack[-1] // Incoming jump from 0x0F1E 0F1F 5B JUMPDEST 0F20 61 PUSH2 0x0f27 0F23 61 PUSH2 0x12fd 0F26 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F20 stack[0] = 0x0f27 } // Block ends with call to 0x12fd, returns to 0x0F27 label_0F27: // Incoming return from call to 0x12FD at 0x0F26 // Inputs[1] { @0F28 stack[-1] } 0F27 5B JUMPDEST 0F28 15 ISZERO 0F29 61 PUSH2 0x0f35 0F2C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f35, if !stack[-1] label_0F2D: // Incoming jump from 0x0F2C, if not !stack[-1] 0F2D 61 PUSH2 0x0f34 0F30 61 PUSH2 0x13d4 0F33 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F2D stack[0] = 0x0f34 } // Block ends with call to 0x13d4, returns to 0x0F34 label_0F34: // Incoming return from call to 0x13D4 at 0x0F33 0F34 5B JUMPDEST // Stack delta = +0 // Block continues label_0F35: // Incoming jump from 0x0F34 // Incoming jump from 0x0F2C, if !stack[-1] // Inputs[5] // { // @0F39 stack[-2] // @0F3C memory[0x40:0x60] // @0F74 stack[-4] // @0FAE memory[0x00:0x40] // @0FAF storage[keccak256(memory[0x00:0x40])] // } 0F35 5B JUMPDEST 0F36 61 PUSH2 0x0fbe 0F39 82 DUP3 0F3A 60 PUSH1 0x40 0F3C 51 MLOAD 0F3D 80 DUP1 0F3E 60 PUSH1 0x40 0F40 01 ADD 0F41 60 PUSH1 0x40 0F43 52 MSTORE 0F44 80 DUP1 0F45 60 PUSH1 0x14 0F47 81 DUP2 0F48 52 MSTORE 0F49 60 PUSH1 0x20 0F4B 01 ADD 0F4C 7F PUSH32 0x496e73756666696369656e742042616c616e6365000000000000000000000000 0F6D 81 DUP2 0F6E 52 MSTORE 0F6F 50 POP 0F70 60 PUSH1 0x05 0F72 60 PUSH1 0x00 0F74 88 DUP9 0F75 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F8A 16 AND 0F8B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FA0 16 AND 0FA1 81 DUP2 0FA2 52 MSTORE 0FA3 60 PUSH1 0x20 0FA5 01 ADD 0FA6 90 SWAP1 0FA7 81 DUP2 0FA8 52 MSTORE 0FA9 60 PUSH1 0x20 0FAB 01 ADD 0FAC 60 PUSH1 0x00 0FAE 20 SHA3 0FAF 54 SLOAD 0FB0 61 PUSH2 0x0cfd 0FB3 90 SWAP1 0FB4 92 SWAP3 0FB5 91 SWAP2 0FB6 90 SWAP1 0FB7 63 PUSH4 0xffffffff 0FBC 16 AND 0FBD 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @0F36 stack[0] = 0x0fbe // @0F43 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0F48 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x14 // @0F6E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x496e73756666696369656e742042616c616e6365000000000000000000000000 // @0FA2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0FA8 memory[0x20:0x40] = 0x05 // @0FB4 stack[1] = storage[keccak256(memory[0x00:0x40])] // @0FB5 stack[2] = stack[-2] // @0FB6 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x0cfd, returns to 0x0FBE label_0FBE: // Incoming return from call to 0x0CFD at 0x0FBD // Inputs[3] // { // @0FC3 stack[-5] // @0FFD memory[0x00:0x40] // @0FFE stack[-1] // } 0FBE 5B JUMPDEST 0FBF 60 PUSH1 0x05 0FC1 60 PUSH1 0x00 0FC3 86 DUP7 0FC4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FD9 16 AND 0FDA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FEF 16 AND 0FF0 81 DUP2 0FF1 52 MSTORE 0FF2 60 PUSH1 0x20 0FF4 01 ADD 0FF5 90 SWAP1 0FF6 81 DUP2 0FF7 52 MSTORE 0FF8 60 PUSH1 0x20 0FFA 01 ADD 0FFB 60 PUSH1 0x00 0FFD 20 SHA3 0FFE 81 DUP2 0FFF 90 SWAP1 1000 55 SSTORE 1001 50 POP 1002 60 PUSH1 0x00 1004 61 PUSH2 0x100c 1007 85 DUP6 1008 61 PUSH2 0x192e 100B 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0FF1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0FF7 memory[0x20:0x40] = 0x05 // @1000 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1002 stack[-1] = 0x00 // @1004 stack[0] = 0x100c // @1007 stack[1] = stack[-5] // } // Block ends with call to 0x192e, returns to 0x100C label_100C: // Incoming return from call to 0x192E at 0x100B // Inputs[1] { @1010 stack[-1] } 100C 5B JUMPDEST 100D 61 PUSH2 0x1016 1010 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1016, if stack[-1] label_1011: // Incoming jump from 0x1010, if not stack[-1] // Inputs[1] { @1011 stack[-3] } 1011 82 DUP3 1012 61 PUSH2 0x1021 1015 56 *JUMP // Stack delta = +1 // Outputs[1] { @1011 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x1021 label_1016: // Incoming jump from 0x1010, if stack[-1] // Inputs[2] // { // @101A stack[-5] // @101B stack[-3] // } 1016 5B JUMPDEST 1017 61 PUSH2 0x1020 101A 85 DUP6 101B 84 DUP5 101C 61 PUSH2 0x1985 101F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1017 stack[0] = 0x1020 // @101A stack[1] = stack[-5] // @101B stack[2] = stack[-3] // } // Block ends with call to 0x1985, returns to 0x1020 label_1020: // Incoming return from call to 0x1985 at 0x101F 1020 5B JUMPDEST // Stack delta = +0 // Block continues label_1021: // Incoming jump from 0x1020 // Incoming jump from 0x1015 // Inputs[5] // { // @1022 stack[-1] // @1022 stack[-2] // @102C stack[-5] // @1066 memory[0x00:0x40] // @1067 storage[keccak256(memory[0x00:0x40])] // } 1021 5B JUMPDEST 1022 90 SWAP1 1023 50 POP 1024 61 PUSH2 0x1075 1027 81 DUP2 1028 60 PUSH1 0x05 102A 60 PUSH1 0x00 102C 87 DUP8 102D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1042 16 AND 1043 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1058 16 AND 1059 81 DUP2 105A 52 MSTORE 105B 60 PUSH1 0x20 105D 01 ADD 105E 90 SWAP1 105F 81 DUP2 1060 52 MSTORE 1061 60 PUSH1 0x20 1063 01 ADD 1064 60 PUSH1 0x00 1066 20 SHA3 1067 54 SLOAD 1068 61 PUSH2 0x1ac9 106B 90 SWAP1 106C 91 SWAP2 106D 90 SWAP1 106E 63 PUSH4 0xffffffff 1073 16 AND 1074 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1022 stack[-2] = stack[-1] // @1024 stack[-1] = 0x1075 // @105A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1060 memory[0x20:0x40] = 0x05 // @106C stack[0] = storage[keccak256(memory[0x00:0x40])] // @106D stack[1] = stack[-1] // } // Block ends with call to 0xffffffff & 0x1ac9, returns to 0x1075 label_1075: // Incoming return from call to 0x1AC9 at 0x1074 // Inputs[6] // { // @107A stack[-5] // @10B4 memory[0x00:0x40] // @10B5 stack[-1] // @10D0 stack[-6] // @1108 stack[-2] // @110B memory[0x40:0x60] // } 1075 5B JUMPDEST 1076 60 PUSH1 0x05 1078 60 PUSH1 0x00 107A 86 DUP7 107B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1090 16 AND 1091 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10A6 16 AND 10A7 81 DUP2 10A8 52 MSTORE 10A9 60 PUSH1 0x20 10AB 01 ADD 10AC 90 SWAP1 10AD 81 DUP2 10AE 52 MSTORE 10AF 60 PUSH1 0x20 10B1 01 ADD 10B2 60 PUSH1 0x00 10B4 20 SHA3 10B5 81 DUP2 10B6 90 SWAP1 10B7 55 SSTORE 10B8 50 POP 10B9 83 DUP4 10BA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10CF 16 AND 10D0 85 DUP6 10D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10E6 16 AND 10E7 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1108 83 DUP4 1109 60 PUSH1 0x40 110B 51 MLOAD 110C 61 PUSH2 0x1115 110F 91 SWAP2 1110 90 SWAP1 1111 61 PUSH2 0x224d 1114 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @10A8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @10AE memory[0x20:0x40] = 0x05 // @10B7 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @10CF stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @10E6 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @10E7 stack[1] = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef // @110F stack[2] = 0x1115 // @1110 stack[3] = stack[-2] // @1110 stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x224d, returns to 0x1115 label_1115: // Incoming return from call to 0x224D at 0x1114 // Inputs[9] // { // @1118 memory[0x40:0x60] // @111A stack[-1] // @111D stack[-4] // @111D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @111D stack[-3] // @111D stack[-2] // @1120 stack[-6] // @1124 stack[-10] // @1125 stack[-9] // } 1115 5B JUMPDEST 1116 60 PUSH1 0x40 1118 51 MLOAD 1119 80 DUP1 111A 91 SWAP2 111B 03 SUB 111C 90 SWAP1 111D A3 LOG3 111E 60 PUSH1 0x01 1120 91 SWAP2 1121 50 POP 1122 50 POP 1123 5B JUMPDEST 1124 93 SWAP4 1125 92 SWAP3 1126 50 POP 1127 50 POP 1128 50 POP 1129 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @111D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); // @1124 stack[-10] = 0x01 // } // Block ends with unconditional jump to stack[-10] label_112A: // Incoming call from 0x0D82, returns to 0x0D83 // Inputs[5] // { // @1130 stack[-1] // @1133 memory[0x40:0x60] // @116B stack[-3] // @11A5 memory[0x00:0x40] // @11A6 storage[keccak256(memory[0x00:0x40])] // } 112A 5B JUMPDEST 112B 60 PUSH1 0x00 112D 61 PUSH2 0x11b5 1130 82 DUP3 1131 60 PUSH1 0x40 1133 51 MLOAD 1134 80 DUP1 1135 60 PUSH1 0x40 1137 01 ADD 1138 60 PUSH1 0x40 113A 52 MSTORE 113B 80 DUP1 113C 60 PUSH1 0x14 113E 81 DUP2 113F 52 MSTORE 1140 60 PUSH1 0x20 1142 01 ADD 1143 7F PUSH32 0x496e73756666696369656e742042616c616e6365000000000000000000000000 1164 81 DUP2 1165 52 MSTORE 1166 50 POP 1167 60 PUSH1 0x05 1169 60 PUSH1 0x00 116B 88 DUP9 116C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1181 16 AND 1182 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1197 16 AND 1198 81 DUP2 1199 52 MSTORE 119A 60 PUSH1 0x20 119C 01 ADD 119D 90 SWAP1 119E 81 DUP2 119F 52 MSTORE 11A0 60 PUSH1 0x20 11A2 01 ADD 11A3 60 PUSH1 0x00 11A5 20 SHA3 11A6 54 SLOAD 11A7 61 PUSH2 0x0cfd 11AA 90 SWAP1 11AB 92 SWAP3 11AC 91 SWAP2 11AD 90 SWAP1 11AE 63 PUSH4 0xffffffff 11B3 16 AND 11B4 56 *JUMP // Stack delta = +5 // Outputs[10] // { // @112B stack[0] = 0x00 // @112D stack[1] = 0x11b5 // @113A memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @113F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x14 // @1165 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x496e73756666696369656e742042616c616e6365000000000000000000000000 // @1199 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @119F memory[0x20:0x40] = 0x05 // @11AB stack[2] = storage[keccak256(memory[0x00:0x40])] // @11AC stack[3] = stack[-1] // @11AD stack[4] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x0cfd, returns to 0x11B5 label_11B5: // Incoming return from call to 0x0CFD at 0x11B4 // Inputs[7] // { // @11BA stack[-5] // @11F4 memory[0x00:0x40] // @11F5 stack[-1] // @11FC stack[-3] // @1201 stack[-4] // @123B memory[0x00:0x40] // @123C storage[keccak256(memory[0x00:0x40])] // } 11B5 5B JUMPDEST 11B6 60 PUSH1 0x05 11B8 60 PUSH1 0x00 11BA 86 DUP7 11BB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11D0 16 AND 11D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11E6 16 AND 11E7 81 DUP2 11E8 52 MSTORE 11E9 60 PUSH1 0x20 11EB 01 ADD 11EC 90 SWAP1 11ED 81 DUP2 11EE 52 MSTORE 11EF 60 PUSH1 0x20 11F1 01 ADD 11F2 60 PUSH1 0x00 11F4 20 SHA3 11F5 81 DUP2 11F6 90 SWAP1 11F7 55 SSTORE 11F8 50 POP 11F9 61 PUSH2 0x124a 11FC 82 DUP3 11FD 60 PUSH1 0x05 11FF 60 PUSH1 0x00 1201 86 DUP7 1202 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1217 16 AND 1218 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 122D 16 AND 122E 81 DUP2 122F 52 MSTORE 1230 60 PUSH1 0x20 1232 01 ADD 1233 90 SWAP1 1234 81 DUP2 1235 52 MSTORE 1236 60 PUSH1 0x20 1238 01 ADD 1239 60 PUSH1 0x00 123B 20 SHA3 123C 54 SLOAD 123D 61 PUSH2 0x1ac9 1240 90 SWAP1 1241 91 SWAP2 1242 90 SWAP1 1243 63 PUSH4 0xffffffff 1248 16 AND 1249 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @11E8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @11EE memory[0x20:0x40] = 0x05 // @11F7 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @11F9 stack[-1] = 0x124a // @122F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1235 memory[0x20:0x40] = 0x05 // @1241 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1242 stack[1] = stack[-3] // } // Block ends with call to 0xffffffff & 0x1ac9, returns to 0x124A label_124A: // Incoming return from call to 0x1AC9 at 0x1249 // Inputs[6] // { // @124F stack[-4] // @1289 memory[0x00:0x40] // @128A stack[-1] // @12A5 stack[-5] // @12DD stack[-3] // @12E0 memory[0x40:0x60] // } 124A 5B JUMPDEST 124B 60 PUSH1 0x05 124D 60 PUSH1 0x00 124F 85 DUP6 1250 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1265 16 AND 1266 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 127B 16 AND 127C 81 DUP2 127D 52 MSTORE 127E 60 PUSH1 0x20 1280 01 ADD 1281 90 SWAP1 1282 81 DUP2 1283 52 MSTORE 1284 60 PUSH1 0x20 1286 01 ADD 1287 60 PUSH1 0x00 1289 20 SHA3 128A 81 DUP2 128B 90 SWAP1 128C 55 SSTORE 128D 50 POP 128E 82 DUP3 128F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12A4 16 AND 12A5 84 DUP5 12A6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12BB 16 AND 12BC 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 12DD 84 DUP5 12DE 60 PUSH1 0x40 12E0 51 MLOAD 12E1 61 PUSH2 0x12ea 12E4 91 SWAP2 12E5 90 SWAP1 12E6 61 PUSH2 0x224d 12E9 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @127D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1283 memory[0x20:0x40] = 0x05 // @128C storage[keccak256(memory[0x00:0x40])] = stack[-1] // @12A4 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @12BB stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @12BC stack[1] = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef // @12E4 stack[2] = 0x12ea // @12E5 stack[3] = stack[-3] // @12E5 stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x224d, returns to 0x12EA label_12EA: // Incoming return from call to 0x224D at 0x12E9 // Inputs[9] // { // @12ED memory[0x40:0x60] // @12EF stack[-1] // @12F2 stack[-3] // @12F2 stack[-2] // @12F2 stack[-4] // @12F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @12F5 stack[-5] // @12F7 stack[-9] // @12F8 stack[-8] // } 12EA 5B JUMPDEST 12EB 60 PUSH1 0x40 12ED 51 MLOAD 12EE 80 DUP1 12EF 91 SWAP2 12F0 03 SUB 12F1 90 SWAP1 12F2 A3 LOG3 12F3 60 PUSH1 0x01 12F5 90 SWAP1 12F6 50 POP 12F7 93 SWAP4 12F8 92 SWAP3 12F9 50 POP 12FA 50 POP 12FB 50 POP 12FC 56 *JUMP // Stack delta = -8 // Outputs[2] // { // @12F2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); // @12F7 stack[-9] = 0x01 // } // Block ends with unconditional jump to stack[-9] label_12FD: // Incoming call from 0x0F26, returns to 0x0F27 // Inputs[2] // { // @1305 storage[0x0f] // @1339 msg.sender // } 12FD 5B JUMPDEST 12FE 60 PUSH1 0x00 1300 60 PUSH1 0x0f 1302 60 PUSH1 0x00 1304 90 SWAP1 1305 54 SLOAD 1306 90 SWAP1 1307 61 PUSH2 0x0100 130A 0A EXP 130B 90 SWAP1 130C 04 DIV 130D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1322 16 AND 1323 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1338 16 AND 1339 33 CALLER 133A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 134F 16 AND 1350 14 EQ 1351 15 ISZERO 1352 80 DUP1 1353 15 ISZERO 1354 61 PUSH2 0x136a 1357 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @12FE stack[0] = 0x00 // @1351 stack[1] = !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) // } // Block ends with conditional jump to 0x136a, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) label_1358: // Incoming jump from 0x1357, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) // Inputs[1] { @135E storage[0x11] } 1358 50 POP 1359 60 PUSH1 0x11 135B 60 PUSH1 0x00 135D 90 SWAP1 135E 54 SLOAD 135F 90 SWAP1 1360 61 PUSH2 0x0100 1363 0A EXP 1364 90 SWAP1 1365 04 DIV 1366 60 PUSH1 0xff 1368 16 AND 1369 15 ISZERO 136A 5B JUMPDEST 136B 80 DUP1 136C 15 ISZERO 136D 61 PUSH2 0x1382 1370 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1369 stack[-1] = !(0xff & storage[0x11] / 0x0100 ** 0x00) } // Block ends with conditional jump to 0x1382, if !!(0xff & storage[0x11] / 0x0100 ** 0x00) label_1371: // Incoming jump from 0x1370, if not !!(0xff & storage[0x11] / 0x0100 ** 0x00) // Incoming jump from 0x1370, if not !stack[-1] // Inputs[1] { @1377 storage[0x0f] } 1371 50 POP 1372 60 PUSH1 0x0f 1374 60 PUSH1 0x14 1376 90 SWAP1 1377 54 SLOAD 1378 90 SWAP1 1379 61 PUSH2 0x0100 137C 0A EXP 137D 90 SWAP1 137E 04 DIV 137F 60 PUSH1 0xff 1381 16 AND 1382 5B JUMPDEST 1383 80 DUP1 1384 15 ISZERO 1385 61 PUSH2 0x13cf 1388 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1381 stack[-1] = 0xff & storage[0x0f] / 0x0100 ** 0x14 } // Block ends with conditional jump to 0x13cf, if !(0xff & storage[0x0f] / 0x0100 ** 0x14) label_1389: // Incoming jump from 0x1388, if not !(0xff & storage[0x0f] / 0x0100 ** 0x14) // Incoming jump from 0x1388, if not !stack[-1] // Inputs[6] // { // @138C storage[0x10] // @1391 address(this) // @13CB memory[0x00:0x40] // @13CC storage[keccak256(memory[0x00:0x40])] // @13D0 stack[-2] // @13D2 stack[-3] // } 1389 50 POP 138A 60 PUSH1 0x10 138C 54 SLOAD 138D 60 PUSH1 0x05 138F 60 PUSH1 0x00 1391 30 ADDRESS 1392 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13A7 16 AND 13A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13BD 16 AND 13BE 81 DUP2 13BF 52 MSTORE 13C0 60 PUSH1 0x20 13C2 01 ADD 13C3 90 SWAP1 13C4 81 DUP2 13C5 52 MSTORE 13C6 60 PUSH1 0x20 13C8 01 ADD 13C9 60 PUSH1 0x00 13CB 20 SHA3 13CC 54 SLOAD 13CD 10 LT 13CE 15 ISZERO 13CF 5B JUMPDEST 13D0 90 SWAP1 13D1 50 POP 13D2 90 SWAP1 13D3 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @13BF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @13C5 memory[0x20:0x40] = 0x05 // @13D2 stack[-3] = !(storage[keccak256(memory[0x00:0x40])] < storage[0x10]) // } // Block ends with unconditional jump to stack[-3] label_13D4: // Incoming call from 0x0F33, returns to 0x0F34 // Inputs[4] // { // @13E0 storage[0x11] // @13F4 storage[0x10] // @1403 storage[0x0b] // @1409 storage[0x09] // } 13D4 5B JUMPDEST 13D5 60 PUSH1 0x01 13D7 60 PUSH1 0x11 13D9 60 PUSH1 0x00 13DB 61 PUSH2 0x0100 13DE 0A EXP 13DF 81 DUP2 13E0 54 SLOAD 13E1 81 DUP2 13E2 60 PUSH1 0xff 13E4 02 MUL 13E5 19 NOT 13E6 16 AND 13E7 90 SWAP1 13E8 83 DUP4 13E9 15 ISZERO 13EA 15 ISZERO 13EB 02 MUL 13EC 17 OR 13ED 90 SWAP1 13EE 55 SSTORE 13EF 50 POP 13F0 60 PUSH1 0x00 13F2 60 PUSH1 0x10 13F4 54 SLOAD 13F5 90 SWAP1 13F6 50 POP 13F7 60 PUSH1 0x00 13F9 61 PUSH2 0x1434 13FC 60 PUSH1 0x02 13FE 61 PUSH2 0x1426 1401 60 PUSH1 0x0b 1403 54 SLOAD 1404 61 PUSH2 0x1418 1407 60 PUSH1 0x09 1409 54 SLOAD 140A 87 DUP8 140B 61 PUSH2 0x1b27 140E 90 SWAP1 140F 91 SWAP2 1410 90 SWAP1 1411 63 PUSH4 0xffffffff 1416 16 AND 1417 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @13EE storage[0x11] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x11]) // @13F5 stack[0] = storage[0x10] // @13F7 stack[1] = 0x00 // @13F9 stack[2] = 0x1434 // @13FC stack[3] = 0x02 // @13FE stack[4] = 0x1426 // @1403 stack[5] = storage[0x0b] // @1404 stack[6] = 0x1418 // @140F stack[7] = storage[0x10] // @1410 stack[8] = storage[0x09] // } // Block ends with call to 0xffffffff & 0x1b27, returns to 0x1418 label_1418: // Incoming return from call to 0x1B27 at 0x1417 // Inputs[2] // { // @141C stack[-1] // @141D stack[-2] // } 1418 5B JUMPDEST 1419 61 PUSH2 0x1ba2 141C 90 SWAP1 141D 91 SWAP2 141E 90 SWAP1 141F 63 PUSH4 0xffffffff 1424 16 AND 1425 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @141D stack[-2] = stack[-1] // @141E stack[-1] = stack[-2] // } // Block ends with unconditional jump to 0xffffffff & 0x1ba2 label_1426: // Incoming return from call to 0x1418 at 0x1417 // Inputs[2] // { // @142A stack[-1] // @142B stack[-2] // } 1426 5B JUMPDEST 1427 61 PUSH2 0x1ba2 142A 90 SWAP1 142B 91 SWAP2 142C 90 SWAP1 142D 63 PUSH4 0xffffffff 1432 16 AND 1433 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @142B stack[-2] = stack[-1] // @142C stack[-1] = stack[-2] // } // Block ends with unconditional jump to 0xffffffff & 0x1ba2 label_1434: // Incoming return from call to 0x1426 at 0x1417 // Inputs[3] // { // @1435 stack[-2] // @1435 stack[-1] // @143D stack[-3] // } 1434 5B JUMPDEST 1435 90 SWAP1 1436 50 POP 1437 60 PUSH1 0x00 1439 61 PUSH2 0x144b 143C 82 DUP3 143D 84 DUP5 143E 61 PUSH2 0x1bec 1441 90 SWAP1 1442 91 SWAP2 1443 90 SWAP1 1444 63 PUSH4 0xffffffff 1449 16 AND 144A 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1435 stack[-2] = stack[-1] // @1437 stack[-1] = 0x00 // @1439 stack[0] = 0x144b // @1442 stack[1] = stack[-3] // @1443 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x1bec, returns to 0x144B label_144B: // Incoming return from call to 0x1BEC at 0x144A // Inputs[2] // { // @144C stack[-2] // @144C stack[-1] // } 144B 5B JUMPDEST 144C 90 SWAP1 144D 50 POP 144E 60 PUSH1 0x00 1450 60 PUSH1 0x02 1452 67 PUSH8 0xffffffffffffffff 145B 81 DUP2 145C 11 GT 145D 15 ISZERO 145E 61 PUSH2 0x146a 1461 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @144C stack[-2] = stack[-1] // @144E stack[-1] = 0x00 // @1450 stack[0] = 0x02 // } // Block ends with conditional jump to 0x146a, if !(0x02 > 0xffffffffffffffff) label_1462: // Incoming jump from 0x1461, if not !(0x02 > 0xffffffffffffffff) 1462 61 PUSH2 0x1469 1465 61 PUSH2 0x25c6 1468 56 *JUMP // Stack delta = +1 // Outputs[1] { @1462 stack[0] = 0x1469 } // Block ends with unconditional jump to 0x25c6 1469 5B JUMPDEST label_146A: // Incoming jump from 0x1461, if !(0x02 > 0xffffffffffffffff) // Inputs[2] // { // @146D memory[0x40:0x60] // @146E stack[-1] // } 146A 5B JUMPDEST 146B 60 PUSH1 0x40 146D 51 MLOAD 146E 90 SWAP1 146F 80 DUP1 1470 82 DUP3 1471 52 MSTORE 1472 80 DUP1 1473 60 PUSH1 0x20 1475 02 MUL 1476 60 PUSH1 0x20 1478 01 ADD 1479 82 DUP3 147A 01 ADD 147B 60 PUSH1 0x40 147D 52 MSTORE 147E 80 DUP1 147F 15 ISZERO 1480 61 PUSH2 0x1498 1483 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @146E stack[-1] = memory[0x40:0x60] // @146E stack[0] = stack[-1] // @1471 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @147D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x1498, if !stack[-1] label_1484: // Incoming jump from 0x1483, if not !stack[-1] // Inputs[7] // { // @1484 stack[-2] // @148A stack[-1] // @148D msg.data.length // @148F msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @149A stack[-3] // @149C address(this) // @14A1 memory[stack[-2]:stack[-2] + 0x20] // } 1484 81 DUP2 1485 60 PUSH1 0x20 1487 01 ADD 1488 60 PUSH1 0x20 148A 82 DUP3 148B 02 MUL 148C 80 DUP1 148D 36 CALLDATASIZE 148E 83 DUP4 148F 37 CALLDATACOPY 1490 80 DUP1 1491 82 DUP3 1492 01 ADD 1493 91 SWAP2 1494 50 POP 1495 50 POP 1496 90 SWAP1 1497 50 POP 1498 5B JUMPDEST 1499 50 POP 149A 90 SWAP1 149B 50 POP 149C 30 ADDRESS 149D 81 DUP2 149E 60 PUSH1 0x00 14A0 81 DUP2 14A1 51 MLOAD 14A2 81 DUP2 14A3 10 LT 14A4 61 PUSH2 0x14b0 14A7 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @148F memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @149A stack[-3] = stack[-2] // @149C stack[-2] = address(this) // @149D stack[-1] = stack[-2] // @149E stack[0] = 0x00 // } // Block ends with conditional jump to 0x14b0, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_14A8: // Incoming jump from 0x14A7, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x14A7, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 14A8 61 PUSH2 0x14af 14AB 61 PUSH2 0x2597 14AE 56 *JUMP // Stack delta = +1 // Outputs[1] { @14A8 stack[0] = 0x14af } // Block ends with unconditional jump to 0x2597 14AF 5B JUMPDEST label_14B0: // Incoming jump from 0x14A7, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x14A7, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[7] // { // @14B3 stack[-1] // @14B7 stack[-2] // @14B8 stack[-3] // @14F0 storage[0x0e] // @152B memory[0x40:0x60] // @153F memory[0x40:0x60] // @1546 address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00).code.length // } 14B0 5B JUMPDEST 14B1 60 PUSH1 0x20 14B3 02 MUL 14B4 60 PUSH1 0x20 14B6 01 ADD 14B7 01 ADD 14B8 90 SWAP1 14B9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14CE 16 AND 14CF 90 SWAP1 14D0 81 DUP2 14D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14E6 16 AND 14E7 81 DUP2 14E8 52 MSTORE 14E9 50 POP 14EA 50 POP 14EB 60 PUSH1 0x0e 14ED 60 PUSH1 0x00 14EF 90 SWAP1 14F0 54 SLOAD 14F1 90 SWAP1 14F2 61 PUSH2 0x0100 14F5 0A EXP 14F6 90 SWAP1 14F7 04 DIV 14F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 150D 16 AND 150E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1523 16 AND 1524 63 PUSH4 0xad5c4648 1529 60 PUSH1 0x40 152B 51 MLOAD 152C 81 DUP2 152D 63 PUSH4 0xffffffff 1532 16 AND 1533 60 PUSH1 0xe0 1535 1B SHL 1536 81 DUP2 1537 52 MSTORE 1538 60 PUSH1 0x04 153A 01 ADD 153B 60 PUSH1 0x20 153D 60 PUSH1 0x40 153F 51 MLOAD 1540 80 DUP1 1541 83 DUP4 1542 03 SUB 1543 81 DUP2 1544 86 DUP7 1545 80 DUP1 1546 3B EXTCODESIZE 1547 15 ISZERO 1548 80 DUP1 1549 15 ISZERO 154A 61 PUSH2 0x1552 154D 57 *JUMPI // Stack delta = +6 // Outputs[11] // { // @14E8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1523 stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 // @1524 stack[-2] = 0xad5c4648 // @1537 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xad5c4648) << 0xe0 // @153A stack[-1] = 0x04 + memory[0x40:0x60] // @153B stack[0] = 0x20 // @153F stack[1] = memory[0x40:0x60] // @1542 stack[2] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1543 stack[3] = memory[0x40:0x60] // @1544 stack[4] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 // @1547 stack[5] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x1552, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00).code.length label_154E: // Incoming jump from 0x154D, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00).code.length // Inputs[1] { @1551 memory[0x00:0x00] } 154E 60 PUSH1 0x00 1550 80 DUP1 1551 FD *REVERT // Stack delta = +0 // Outputs[1] { @1551 revert(memory[0x00:0x00]); } // Block terminates label_1552: // Incoming jump from 0x154D, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00).code.length // Inputs[8] // { // @1554 msg.gas // @1555 stack[-4] // @1555 stack[-3] // @1555 stack[-6] // @1555 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1555 memory[stack[-3]:stack[-3] + stack[-4]] // @1555 stack[-5] // @1555 stack[-2] // } 1552 5B JUMPDEST 1553 50 POP 1554 5A GAS 1555 FA STATICCALL 1556 15 ISZERO 1557 80 DUP1 1558 15 ISZERO 1559 61 PUSH2 0x1566 155C 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1555 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1556 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1566, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_155D: // Incoming jump from 0x155C, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @155D returndata.length // @1561 returndata[0x00:0x00 + returndata.length] // @1562 returndata.length // @1565 memory[0x00:0x00 + returndata.length] // } 155D 3D RETURNDATASIZE 155E 60 PUSH1 0x00 1560 80 DUP1 1561 3E RETURNDATACOPY 1562 3D RETURNDATASIZE 1563 60 PUSH1 0x00 1565 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1561 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1565 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1566: // Incoming jump from 0x155C, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @156D memory[0x40:0x60] // @156E returndata.length // } 1566 5B JUMPDEST 1567 50 POP 1568 50 POP 1569 50 POP 156A 50 POP 156B 60 PUSH1 0x40 156D 51 MLOAD 156E 3D RETURNDATASIZE 156F 60 PUSH1 0x1f 1571 19 NOT 1572 60 PUSH1 0x1f 1574 82 DUP3 1575 01 ADD 1576 16 AND 1577 82 DUP3 1578 01 ADD 1579 80 DUP1 157A 60 PUSH1 0x40 157C 52 MSTORE 157D 50 POP 157E 81 DUP2 157F 01 ADD 1580 90 SWAP1 1581 61 PUSH2 0x158a 1584 91 SWAP2 1585 90 SWAP1 1586 61 PUSH2 0x1d1a 1589 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @157C memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1584 stack[-4] = 0x158a // @1585 stack[-2] = memory[0x40:0x60] // @1585 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x1d1a, returns to 0x158A label_158A: // Incoming return from call to 0x1D1A at 0x1589 // Inputs[2] // { // @158B stack[-2] // @158F memory[stack[-2]:stack[-2] + 0x20] // } 158A 5B JUMPDEST 158B 81 DUP2 158C 60 PUSH1 0x01 158E 81 DUP2 158F 51 MLOAD 1590 81 DUP2 1591 10 LT 1592 61 PUSH2 0x159e 1595 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @158B stack[0] = stack[-2] // @158C stack[1] = 0x01 // } // Block ends with conditional jump to 0x159e, if 0x01 < memory[stack[-2]:stack[-2] + 0x20] label_1596: // Incoming jump from 0x1595, if not 0x01 < memory[stack[-2]:stack[-2] + 0x20] 1596 61 PUSH2 0x159d 1599 61 PUSH2 0x2597 159C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1596 stack[0] = 0x159d } // Block ends with unconditional jump to 0x2597 159D 5B JUMPDEST label_159E: // Incoming jump from 0x1595, if 0x01 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[11] // { // @15A1 stack[-1] // @15A5 stack[-2] // @15A6 stack[-3] // @15DB address(this).balance // @15DB address(this) // @15E3 storage[0x0e] // @161C stack[-5] // @161F stack[-4] // @1620 address(this) // @1621 block.timestamp // @1624 memory[0x40:0x60] // } 159E 5B JUMPDEST 159F 60 PUSH1 0x20 15A1 02 MUL 15A2 60 PUSH1 0x20 15A4 01 ADD 15A5 01 ADD 15A6 90 SWAP1 15A7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15BC 16 AND 15BD 90 SWAP1 15BE 81 DUP2 15BF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15D4 16 AND 15D5 81 DUP2 15D6 52 MSTORE 15D7 50 POP 15D8 50 POP 15D9 60 PUSH1 0x00 15DB 47 SELFBALANCE 15DC 90 SWAP1 15DD 50 POP 15DE 60 PUSH1 0x0e 15E0 60 PUSH1 0x00 15E2 90 SWAP1 15E3 54 SLOAD 15E4 90 SWAP1 15E5 61 PUSH2 0x0100 15E8 0A EXP 15E9 90 SWAP1 15EA 04 DIV 15EB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1600 16 AND 1601 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1616 16 AND 1617 63 PUSH4 0x791ac947 161C 84 DUP5 161D 60 PUSH1 0x00 161F 85 DUP6 1620 30 ADDRESS 1621 42 TIMESTAMP 1622 60 PUSH1 0x40 1624 51 MLOAD 1625 86 DUP7 1626 63 PUSH4 0xffffffff 162B 16 AND 162C 60 PUSH1 0xe0 162E 1B SHL 162F 81 DUP2 1630 52 MSTORE 1631 60 PUSH1 0x04 1633 01 ADD 1634 61 PUSH2 0x1641 1637 95 SWAP6 1638 94 SWAP5 1639 93 SWAP4 163A 92 SWAP3 163B 91 SWAP2 163C 90 SWAP1 163D 61 PUSH2 0x2268 1640 56 *JUMP // Stack delta = +7 // Outputs[12] // { // @15D6 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @15DC stack[-3] = address(this).balance // @1616 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 // @1617 stack[-1] = 0x791ac947 // @1630 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x791ac947) << 0xe0 // @1637 stack[0] = 0x1641 // @1638 stack[1] = stack[-5] // @1639 stack[2] = 0x00 // @163A stack[3] = stack[-4] // @163B stack[4] = address(this) // @163C stack[6] = 0x04 + memory[0x40:0x60] // @163C stack[5] = block.timestamp // } // Block ends with call to 0x2268, returns to 0x1641 label_1641: // Incoming return from call to 0x2268 at 0x1640 // Inputs[4] // { // @1646 memory[0x40:0x60] // @1648 stack[-1] // @164D stack[-3] // @164F address(stack[-3]).code.length // } 1641 5B JUMPDEST 1642 60 PUSH1 0x00 1644 60 PUSH1 0x40 1646 51 MLOAD 1647 80 DUP1 1648 83 DUP4 1649 03 SUB 164A 81 DUP2 164B 60 PUSH1 0x00 164D 87 DUP8 164E 80 DUP1 164F 3B EXTCODESIZE 1650 15 ISZERO 1651 80 DUP1 1652 15 ISZERO 1653 61 PUSH2 0x165b 1656 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1642 stack[0] = 0x00 // @1646 stack[1] = memory[0x40:0x60] // @1649 stack[2] = stack[-1] - memory[0x40:0x60] // @164A stack[3] = memory[0x40:0x60] // @164B stack[4] = 0x00 // @164D stack[5] = stack[-3] // @1650 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x165b, if !!address(stack[-3]).code.length label_1657: // Incoming jump from 0x1656, if not !!address(stack[-3]).code.length // Inputs[1] { @165A memory[0x00:0x00] } 1657 60 PUSH1 0x00 1659 80 DUP1 165A FD *REVERT // Stack delta = +0 // Outputs[1] { @165A revert(memory[0x00:0x00]); } // Block terminates label_165B: // Incoming jump from 0x1656, if !!address(stack[-3]).code.length // Inputs[9] // { // @165D msg.gas // @165E stack[-2] // @165E stack[-6] // @165E stack[-4] // @165E address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @165E stack[-3] // @165E memory[stack[-4]:stack[-4] + stack[-5]] // @165E stack[-7] // @165E stack[-5] // } 165B 5B JUMPDEST 165C 50 POP 165D 5A GAS 165E F1 CALL 165F 15 ISZERO 1660 80 DUP1 1661 15 ISZERO 1662 61 PUSH2 0x166f 1665 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @165E memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @165F stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x166f, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1666: // Incoming jump from 0x1665, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1666 returndata.length // @166A returndata[0x00:0x00 + returndata.length] // @166B returndata.length // @166E memory[0x00:0x00 + returndata.length] // } 1666 3D RETURNDATASIZE 1667 60 PUSH1 0x00 1669 80 DUP1 166A 3E RETURNDATACOPY 166B 3D RETURNDATASIZE 166C 60 PUSH1 0x00 166E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @166A memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @166E revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_166F: // Incoming jump from 0x1665, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[3] // { // @1679 stack[-5] // @167A address(this) // @167A address(this).balance // } 166F 5B JUMPDEST 1670 50 POP 1671 50 POP 1672 50 POP 1673 50 POP 1674 60 PUSH1 0x00 1676 61 PUSH2 0x1688 1679 82 DUP3 167A 47 SELFBALANCE 167B 61 PUSH2 0x1bec 167E 90 SWAP1 167F 91 SWAP2 1680 90 SWAP1 1681 63 PUSH4 0xffffffff 1686 16 AND 1687 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1674 stack[-4] = 0x00 // @1676 stack[-3] = 0x1688 // @167F stack[-2] = address(this).balance // @1680 stack[-1] = stack[-5] // } // Block ends with call to 0xffffffff & 0x1bec, returns to 0x1688 label_1688: // Incoming return from call to 0x1BEC at 0x1687 // Inputs[3] // { // @1689 stack[-2] // @1689 stack[-1] // @1697 storage[0x09] // } 1688 5B JUMPDEST 1689 90 SWAP1 168A 50 POP 168B 60 PUSH1 0x00 168D 61 PUSH2 0x16b6 1690 61 PUSH2 0x16a5 1693 60 PUSH1 0x02 1695 60 PUSH1 0x09 1697 54 SLOAD 1698 61 PUSH2 0x1ba2 169B 90 SWAP1 169C 91 SWAP2 169D 90 SWAP1 169E 63 PUSH4 0xffffffff 16A3 16 AND 16A4 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1689 stack[-2] = stack[-1] // @168B stack[-1] = 0x00 // @168D stack[0] = 0x16b6 // @1690 stack[1] = 0x16a5 // @169C stack[2] = storage[0x09] // @169D stack[3] = 0x02 // } // Block ends with call to 0xffffffff & 0x1ba2, returns to 0x16A5 label_16A5: // Incoming return from call to 0x1BA2 at 0x16A4 // Inputs[2] // { // @16A8 storage[0x0b] // @16AD stack[-1] // } 16A5 5B JUMPDEST 16A6 60 PUSH1 0x0b 16A8 54 SLOAD 16A9 61 PUSH2 0x1bec 16AC 90 SWAP1 16AD 91 SWAP2 16AE 90 SWAP1 16AF 63 PUSH4 0xffffffff 16B4 16 AND 16B5 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @16AD stack[-1] = storage[0x0b] // @16AE stack[0] = stack[-1] // } // Block ends with unconditional jump to 0xffffffff & 0x1bec label_16B6: // Incoming return from call to 0x16A5 at 0x16A4 // Inputs[4] // { // @16B7 stack[-2] // @16B7 stack[-1] // @16C9 storage[0x09] // @16CA stack[-3] // } 16B6 5B JUMPDEST 16B7 90 SWAP1 16B8 50 POP 16B9 60 PUSH1 0x00 16BB 61 PUSH2 0x16f4 16BE 60 PUSH1 0x02 16C0 61 PUSH2 0x16e6 16C3 84 DUP5 16C4 61 PUSH2 0x16d8 16C7 60 PUSH1 0x09 16C9 54 SLOAD 16CA 88 DUP9 16CB 61 PUSH2 0x1b27 16CE 90 SWAP1 16CF 91 SWAP2 16D0 90 SWAP1 16D1 63 PUSH4 0xffffffff 16D6 16 AND 16D7 56 *JUMP // Stack delta = +7 // Outputs[9] // { // @16B7 stack[-2] = stack[-1] // @16B9 stack[-1] = 0x00 // @16BB stack[0] = 0x16f4 // @16BE stack[1] = 0x02 // @16C0 stack[2] = 0x16e6 // @16C3 stack[3] = stack[-1] // @16C4 stack[4] = 0x16d8 // @16CF stack[5] = stack[-3] // @16D0 stack[6] = storage[0x09] // } // Block ends with call to 0xffffffff & 0x1b27, returns to 0x16D8 label_16D8: // Incoming return from call to 0x1B27 at 0x16D7 // Inputs[2] // { // @16DC stack[-1] // @16DD stack[-2] // } 16D8 5B JUMPDEST 16D9 61 PUSH2 0x1ba2 16DC 90 SWAP1 16DD 91 SWAP2 16DE 90 SWAP1 16DF 63 PUSH4 0xffffffff 16E4 16 AND 16E5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @16DD stack[-2] = stack[-1] // @16DE stack[-1] = stack[-2] // } // Block ends with unconditional jump to 0xffffffff & 0x1ba2 label_16E6: // Incoming return from call to 0x16D8 at 0x16D7 // Inputs[2] // { // @16EA stack[-1] // @16EB stack[-2] // } 16E6 5B JUMPDEST 16E7 61 PUSH2 0x1ba2 16EA 90 SWAP1 16EB 91 SWAP2 16EC 90 SWAP1 16ED 63 PUSH4 0xffffffff 16F2 16 AND 16F3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @16EB stack[-2] = stack[-1] // @16EC stack[-1] = stack[-2] // } // Block ends with unconditional jump to 0xffffffff & 0x1ba2 label_16F4: // Incoming return from call to 0x16E6 at 0x16D7 // Inputs[5] // { // @16F5 stack[-2] // @16F5 stack[-1] // @16FC stack[-3] // @1702 storage[0x0a] // @1703 stack[-4] // } 16F4 5B JUMPDEST 16F5 90 SWAP1 16F6 50 POP 16F7 60 PUSH1 0x00 16F9 61 PUSH2 0x171f 16FC 83 DUP4 16FD 61 PUSH2 0x1711 1700 60 PUSH1 0x0a 1702 54 SLOAD 1703 87 DUP8 1704 61 PUSH2 0x1b27 1707 90 SWAP1 1708 91 SWAP2 1709 90 SWAP1 170A 63 PUSH4 0xffffffff 170F 16 AND 1710 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @16F5 stack[-2] = stack[-1] // @16F7 stack[-1] = 0x00 // @16F9 stack[0] = 0x171f // @16FC stack[1] = stack[-3] // @16FD stack[2] = 0x1711 // @1708 stack[3] = stack[-4] // @1709 stack[4] = storage[0x0a] // } // Block ends with call to 0xffffffff & 0x1b27, returns to 0x1711 label_1711: // Incoming return from call to 0x1B27 at 0x1710 // Inputs[2] // { // @1715 stack[-1] // @1716 stack[-2] // } 1711 5B JUMPDEST 1712 61 PUSH2 0x1ba2 1715 90 SWAP1 1716 91 SWAP2 1717 90 SWAP1 1718 63 PUSH4 0xffffffff 171D 16 AND 171E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1716 stack[-2] = stack[-1] // @1717 stack[-1] = stack[-2] // } // Block ends with unconditional jump to 0xffffffff & 0x1ba2 label_171F: // Incoming return from call to 0x1711 at 0x1710 // Inputs[4] // { // @1720 stack[-2] // @1720 stack[-1] // @1729 storage[0x0d] // @1764 memory[0x40:0x60] // } 171F 5B JUMPDEST 1720 90 SWAP1 1721 50 POP 1722 60 PUSH1 0x00 1724 60 PUSH1 0x0d 1726 60 PUSH1 0x00 1728 90 SWAP1 1729 54 SLOAD 172A 90 SWAP1 172B 61 PUSH2 0x0100 172E 0A EXP 172F 90 SWAP1 1730 04 DIV 1731 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1746 16 AND 1747 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 175C 16 AND 175D 82 DUP3 175E 61 PUSH2 0x7530 1761 90 SWAP1 1762 60 PUSH1 0x40 1764 51 MLOAD 1765 61 PUSH2 0x176d 1768 90 SWAP1 1769 61 PUSH2 0x20c4 176C 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1720 stack[-2] = stack[-1] // @1722 stack[-1] = 0x00 // @175C stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 // @1761 stack[1] = 0x7530 // @1761 stack[2] = stack[-1] // @1768 stack[4] = memory[0x40:0x60] // @1768 stack[3] = 0x176d // } // Block ends with call to 0x20c4, returns to 0x176D label_176D: // Incoming return from call to 0x20C4 at 0x176C // Inputs[8] // { // @1772 memory[0x40:0x60] // @1774 stack[-1] // @1777 stack[-2] // @1778 stack[-4] // @1779 stack[-3] // @177A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @177A address(stack[-4]).call.gas(stack[-3]).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1780 returndata.length // } 176D 5B JUMPDEST 176E 60 PUSH1 0x00 1770 60 PUSH1 0x40 1772 51 MLOAD 1773 80 DUP1 1774 83 DUP4 1775 03 SUB 1776 81 DUP2 1777 85 DUP6 1778 88 DUP9 1779 88 DUP9 177A F1 CALL 177B 93 SWAP4 177C 50 POP 177D 50 POP 177E 50 POP 177F 50 POP 1780 3D RETURNDATASIZE 1781 80 DUP1 1782 60 PUSH1 0x00 1784 81 DUP2 1785 14 EQ 1786 61 PUSH2 0x17ab 1789 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @177A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-4]).call.gas(stack[-3]).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @177B stack[-4] = address(stack[-4]).call.gas(stack[-3]).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1780 stack[-3] = returndata.length // @1781 stack[-2] = returndata.length // } // Block ends with conditional jump to 0x17ab, if returndata.length == 0x00 label_178A: // Incoming jump from 0x1789, if not returndata.length == 0x00 // Inputs[6] // { // @178C memory[0x40:0x60] // @178D stack[-2] // @1794 returndata.length // @179C returndata.length // @179F returndata.length // @17A6 returndata[0x00:0x00 + returndata.length] // } 178A 60 PUSH1 0x40 178C 51 MLOAD 178D 91 SWAP2 178E 50 POP 178F 60 PUSH1 0x1f 1791 19 NOT 1792 60 PUSH1 0x3f 1794 3D RETURNDATASIZE 1795 01 ADD 1796 16 AND 1797 82 DUP3 1798 01 ADD 1799 60 PUSH1 0x40 179B 52 MSTORE 179C 3D RETURNDATASIZE 179D 82 DUP3 179E 52 MSTORE 179F 3D RETURNDATASIZE 17A0 60 PUSH1 0x00 17A2 60 PUSH1 0x20 17A4 84 DUP5 17A5 01 ADD 17A6 3E RETURNDATACOPY 17A7 61 PUSH2 0x17b0 17AA 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @178D stack[-2] = memory[0x40:0x60] // @179B memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @179E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @17A6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x17b0 label_17AB: // Incoming jump from 0x1789, if returndata.length == 0x00 // Inputs[3] // { // @17AE stack[-2] // @17B3 stack[-4] // @17B3 stack[-3] // } 17AB 5B JUMPDEST 17AC 60 PUSH1 0x60 17AE 91 SWAP2 17AF 50 POP 17B0 5B JUMPDEST 17B1 50 POP 17B2 50 POP 17B3 90 SWAP1 17B4 50 POP 17B5 80 DUP1 17B6 61 PUSH2 0x17f4 17B9 57 *JUMPI // Stack delta = -3 // Outputs[1] { @17B3 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x17f4, if stack[-3] label_17BA: // Incoming jump from 0x17B9, if not stack[-3] // Incoming jump from 0x17B9, if not stack[-3] // Inputs[1] { @17BC memory[0x40:0x60] } 17BA 60 PUSH1 0x40 17BC 51 MLOAD 17BD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 17DE 81 DUP2 17DF 52 MSTORE 17E0 60 PUSH1 0x04 17E2 01 ADD 17E3 61 PUSH2 0x17eb 17E6 90 SWAP1 17E7 61 PUSH2 0x21ed 17EA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @17E6 stack[0] = 0x17eb // @17E6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x21ed, returns to 0x17EB label_17EB: // Incoming return from call to 0x21ED at 0x17EA // Inputs[3] // { // @17EE memory[0x40:0x60] // @17F0 stack[-1] // @17F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 17EB 5B JUMPDEST 17EC 60 PUSH1 0x40 17EE 51 MLOAD 17EF 80 DUP1 17F0 91 SWAP2 17F1 03 SUB 17F2 90 SWAP1 17F3 FD *REVERT // Stack delta = -1 // Outputs[1] { @17F3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_17F4: // Incoming jump from 0x17B9, if stack[-3] // Incoming jump from 0x17B9, if stack[-3] // Inputs[1] { @17F7 stack[-9] } 17F4 5B JUMPDEST 17F5 60 PUSH1 0x00 17F7 89 DUP10 17F8 11 GT 17F9 15 ISZERO 17FA 61 PUSH2 0x1907 17FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1907, if !(stack[-9] > 0x00) label_17FE: // Incoming jump from 0x17FD, if not !(stack[-9] > 0x00) // Inputs[6] // { // @1803 storage[0x0e] // @183C stack[-3] // @183D address(this) // @183E stack[-9] // @1857 block.timestamp // @185A memory[0x40:0x60] // } 17FE 60 PUSH1 0x0e 1800 60 PUSH1 0x00 1802 90 SWAP1 1803 54 SLOAD 1804 90 SWAP1 1805 61 PUSH2 0x0100 1808 0A EXP 1809 90 SWAP1 180A 04 DIV 180B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1820 16 AND 1821 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1836 16 AND 1837 63 PUSH4 0xf305d719 183C 84 DUP5 183D 30 ADDRESS 183E 8C DUP13 183F 60 PUSH1 0x00 1841 80 DUP1 1842 73 PUSH20 0xc35259944d57f06c349d213da20a152290b2cedd 1857 42 TIMESTAMP 1858 60 PUSH1 0x40 185A 51 MLOAD 185B 88 DUP9 185C 63 PUSH4 0xffffffff 1861 16 AND 1862 60 PUSH1 0xe0 1864 1B SHL 1865 81 DUP2 1866 52 MSTORE 1867 60 PUSH1 0x04 1869 01 ADD 186A 61 PUSH2 0x1878 186D 96 SWAP7 186E 95 SWAP6 186F 94 SWAP5 1870 93 SWAP4 1871 92 SWAP3 1872 91 SWAP2 1873 90 SWAP1 1874 61 PUSH2 0x20f4 1877 56 *JUMP // Stack delta = +11 // Outputs[12] // { // @1836 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 // @1837 stack[1] = 0xf305d719 // @183C stack[2] = stack[-3] // @1866 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xf305d719) << 0xe0 // @186D stack[3] = 0x1878 // @186E stack[4] = address(this) // @186F stack[5] = stack[-9] // @1870 stack[6] = 0x00 // @1871 stack[7] = 0x00 // @1872 stack[8] = 0xc35259944d57f06c349d213da20a152290b2cedd // @1873 stack[9] = block.timestamp // @1873 stack[10] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x20f4, returns to 0x1878 label_1878: // Incoming return from call to 0x20F4 at 0x1877 // Inputs[5] // { // @187D memory[0x40:0x60] // @187F stack[-1] // @1882 stack[-2] // @1883 stack[-4] // @1885 address(stack[-4]).code.length // } 1878 5B JUMPDEST 1879 60 PUSH1 0x60 187B 60 PUSH1 0x40 187D 51 MLOAD 187E 80 DUP1 187F 83 DUP4 1880 03 SUB 1881 81 DUP2 1882 85 DUP6 1883 88 DUP9 1884 80 DUP1 1885 3B EXTCODESIZE 1886 15 ISZERO 1887 80 DUP1 1888 15 ISZERO 1889 61 PUSH2 0x1891 188C 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1879 stack[0] = 0x60 // @187D stack[1] = memory[0x40:0x60] // @1880 stack[2] = stack[-1] - memory[0x40:0x60] // @1881 stack[3] = memory[0x40:0x60] // @1882 stack[4] = stack[-2] // @1883 stack[5] = stack[-4] // @1886 stack[6] = !address(stack[-4]).code.length // } // Block ends with conditional jump to 0x1891, if !!address(stack[-4]).code.length label_188D: // Incoming jump from 0x188C, if not !!address(stack[-4]).code.length // Inputs[1] { @1890 memory[0x00:0x00] } 188D 60 PUSH1 0x00 188F 80 DUP1 1890 FD *REVERT // Stack delta = +0 // Outputs[1] { @1890 revert(memory[0x00:0x00]); } // Block terminates label_1891: // Incoming jump from 0x188C, if !!address(stack[-4]).code.length // Inputs[9] // { // @1893 msg.gas // @1894 stack[-7] // @1894 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1894 stack[-5] // @1894 stack[-2] // @1894 stack[-3] // @1894 stack[-6] // @1894 memory[stack[-4]:stack[-4] + stack[-5]] // @1894 stack[-4] // } 1891 5B JUMPDEST 1892 50 POP 1893 5A GAS 1894 F1 CALL 1895 15 ISZERO 1896 80 DUP1 1897 15 ISZERO 1898 61 PUSH2 0x18a5 189B 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1894 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1895 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x18a5, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_189C: // Incoming jump from 0x189B, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @189C returndata.length // @18A0 returndata[0x00:0x00 + returndata.length] // @18A1 returndata.length // @18A4 memory[0x00:0x00 + returndata.length] // } 189C 3D RETURNDATASIZE 189D 60 PUSH1 0x00 189F 80 DUP1 18A0 3E RETURNDATACOPY 18A1 3D RETURNDATASIZE 18A2 60 PUSH1 0x00 18A4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @18A0 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @18A4 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_18A5: // Incoming jump from 0x189B, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @18AD memory[0x40:0x60] // @18AE returndata.length // } 18A5 5B JUMPDEST 18A6 50 POP 18A7 50 POP 18A8 50 POP 18A9 50 POP 18AA 50 POP 18AB 60 PUSH1 0x40 18AD 51 MLOAD 18AE 3D RETURNDATASIZE 18AF 60 PUSH1 0x1f 18B1 19 NOT 18B2 60 PUSH1 0x1f 18B4 82 DUP3 18B5 01 ADD 18B6 16 AND 18B7 82 DUP3 18B8 01 ADD 18B9 80 DUP1 18BA 60 PUSH1 0x40 18BC 52 MSTORE 18BD 50 POP 18BE 81 DUP2 18BF 01 ADD 18C0 90 SWAP1 18C1 61 PUSH2 0x18ca 18C4 91 SWAP2 18C5 90 SWAP1 18C6 61 PUSH2 0x1e87 18C9 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @18BC memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @18C4 stack[-5] = 0x18ca // @18C5 stack[-3] = memory[0x40:0x60] // @18C5 stack[-4] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x1e87, returns to 0x18CA label_18CA: // Incoming return from call to 0x1E87 at 0x18C9 // Inputs[3] // { // @18EF stack[-6] // @18F0 stack[-12] // @18F3 memory[0x40:0x60] // } 18CA 5B JUMPDEST 18CB 50 POP 18CC 50 POP 18CD 50 POP 18CE 7F PUSH32 0x424db2872186fa7e7afa7a5e902ed3b49a2ef19c2f5431e672462495dd6b4506 18EF 83 DUP4 18F0 8A DUP11 18F1 60 PUSH1 0x40 18F3 51 MLOAD 18F4 61 PUSH2 0x18fe 18F7 92 SWAP3 18F8 91 SWAP2 18F9 90 SWAP1 18FA 61 PUSH2 0x22c2 18FD 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @18CE stack[-3] = 0x424db2872186fa7e7afa7a5e902ed3b49a2ef19c2f5431e672462495dd6b4506 // @18F7 stack[-2] = 0x18fe // @18F8 stack[-1] = stack[-6] // @18F9 stack[1] = memory[0x40:0x60] // @18F9 stack[0] = stack[-12] // } // Block ends with call to 0x22c2, returns to 0x18FE label_18FE: // Incoming return from call to 0x22C2 at 0x18FD // Inputs[4] // { // @1901 memory[0x40:0x60] // @1903 stack[-1] // @1906 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1906 stack[-2] // } 18FE 5B JUMPDEST 18FF 60 PUSH1 0x40 1901 51 MLOAD 1902 80 DUP1 1903 91 SWAP2 1904 03 SUB 1905 90 SWAP1 1906 A1 LOG1 // Stack delta = -2 // Outputs[1] { @1906 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2]]); } // Block continues label_1907: // Incoming jump from 0x1906 // Incoming jump from 0x17FD, if !(stack[-9] > 0x00) // Inputs[2] // { // @191D storage[0x11] // @192D stack[-11] // } 1907 5B JUMPDEST 1908 50 POP 1909 50 POP 190A 50 POP 190B 50 POP 190C 50 POP 190D 50 POP 190E 50 POP 190F 50 POP 1910 50 POP 1911 50 POP 1912 60 PUSH1 0x00 1914 60 PUSH1 0x11 1916 60 PUSH1 0x00 1918 61 PUSH2 0x0100 191B 0A EXP 191C 81 DUP2 191D 54 SLOAD 191E 81 DUP2 191F 60 PUSH1 0xff 1921 02 MUL 1922 19 NOT 1923 16 AND 1924 90 SWAP1 1925 83 DUP4 1926 15 ISZERO 1927 15 ISZERO 1928 02 MUL 1929 17 OR 192A 90 SWAP1 192B 55 SSTORE 192C 50 POP 192D 56 *JUMP // Stack delta = -11 // Outputs[1] { @192B storage[0x11] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x11]) } // Block ends with unconditional jump to stack[-11] label_192E: // Incoming call from 0x100B, returns to 0x100C // Inputs[4] // { // @1935 stack[-1] // @196F memory[0x00:0x40] // @1973 storage[keccak256(memory[0x00:0x40])] // @1981 stack[-2] // } 192E 5B JUMPDEST 192F 60 PUSH1 0x00 1931 60 PUSH1 0x07 1933 60 PUSH1 0x00 1935 83 DUP4 1936 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 194B 16 AND 194C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1961 16 AND 1962 81 DUP2 1963 52 MSTORE 1964 60 PUSH1 0x20 1966 01 ADD 1967 90 SWAP1 1968 81 DUP2 1969 52 MSTORE 196A 60 PUSH1 0x20 196C 01 ADD 196D 60 PUSH1 0x00 196F 20 SHA3 1970 60 PUSH1 0x00 1972 90 SWAP1 1973 54 SLOAD 1974 90 SWAP1 1975 61 PUSH2 0x0100 1978 0A EXP 1979 90 SWAP1 197A 04 DIV 197B 60 PUSH1 0xff 197D 16 AND 197E 15 ISZERO 197F 90 SWAP1 1980 50 POP 1981 91 SWAP2 1982 90 SWAP1 1983 50 POP 1984 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1963 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1969 memory[0x20:0x40] = 0x07 // @1981 stack[-2] = !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // } // Block ends with unconditional jump to stack[-2] label_1985: // Incoming call from 0x101F, returns to 0x1020 // Inputs[3] // { // @198E storage[0x0c] // @1994 storage[0x0b] // @1995 stack[-1] // } 1985 5B JUMPDEST 1986 60 PUSH1 0x00 1988 80 DUP1 1989 61 PUSH2 0x19b1 198C 60 PUSH1 0x0c 198E 54 SLOAD 198F 61 PUSH2 0x19a3 1992 60 PUSH1 0x0b 1994 54 SLOAD 1995 86 DUP7 1996 61 PUSH2 0x1b27 1999 90 SWAP1 199A 91 SWAP2 199B 90 SWAP1 199C 63 PUSH4 0xffffffff 19A1 16 AND 19A2 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1986 stack[0] = 0x00 // @1988 stack[1] = 0x00 // @1989 stack[2] = 0x19b1 // @198E stack[3] = storage[0x0c] // @198F stack[4] = 0x19a3 // @199A stack[5] = stack[-1] // @199B stack[6] = storage[0x0b] // } // Block ends with call to 0xffffffff & 0x1b27, returns to 0x19A3 label_19A3: // Incoming return from call to 0x1B27 at 0x19A2 // Inputs[2] // { // @19A7 stack[-1] // @19A8 stack[-2] // } 19A3 5B JUMPDEST 19A4 61 PUSH2 0x1ba2 19A7 90 SWAP1 19A8 91 SWAP2 19A9 90 SWAP1 19AA 63 PUSH4 0xffffffff 19AF 16 AND 19B0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @19A8 stack[-2] = stack[-1] // @19A9 stack[-1] = stack[-2] // } // Block ends with unconditional jump to 0xffffffff & 0x1ba2 label_19B1: // Incoming return from call to 0x19A3 at 0x19A2 // Inputs[5] // { // @19B2 stack[-1] // @19B2 stack[-2] // @19BC address(this) // @19F6 memory[0x00:0x40] // @19F7 storage[keccak256(memory[0x00:0x40])] // } 19B1 5B JUMPDEST 19B2 90 SWAP1 19B3 50 POP 19B4 61 PUSH2 0x1a05 19B7 81 DUP2 19B8 60 PUSH1 0x05 19BA 60 PUSH1 0x00 19BC 30 ADDRESS 19BD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19D2 16 AND 19D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19E8 16 AND 19E9 81 DUP2 19EA 52 MSTORE 19EB 60 PUSH1 0x20 19ED 01 ADD 19EE 90 SWAP1 19EF 81 DUP2 19F0 52 MSTORE 19F1 60 PUSH1 0x20 19F3 01 ADD 19F4 60 PUSH1 0x00 19F6 20 SHA3 19F7 54 SLOAD 19F8 61 PUSH2 0x1ac9 19FB 90 SWAP1 19FC 91 SWAP2 19FD 90 SWAP1 19FE 63 PUSH4 0xffffffff 1A03 16 AND 1A04 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @19B2 stack[-2] = stack[-1] // @19B4 stack[-1] = 0x1a05 // @19EA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @19F0 memory[0x20:0x40] = 0x05 // @19FC stack[0] = storage[keccak256(memory[0x00:0x40])] // @19FD stack[1] = stack[-1] // } // Block ends with call to 0xffffffff & 0x1ac9, returns to 0x1A05 label_1A05: // Incoming return from call to 0x1AC9 at 0x1A04 // Inputs[7] // { // @1A0A address(this) // @1A44 memory[0x00:0x40] // @1A45 stack[-1] // @1A49 address(this) // @1A60 stack[-5] // @1A98 stack[-2] // @1A9B memory[0x40:0x60] // } 1A05 5B JUMPDEST 1A06 60 PUSH1 0x05 1A08 60 PUSH1 0x00 1A0A 30 ADDRESS 1A0B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A20 16 AND 1A21 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A36 16 AND 1A37 81 DUP2 1A38 52 MSTORE 1A39 60 PUSH1 0x20 1A3B 01 ADD 1A3C 90 SWAP1 1A3D 81 DUP2 1A3E 52 MSTORE 1A3F 60 PUSH1 0x20 1A41 01 ADD 1A42 60 PUSH1 0x00 1A44 20 SHA3 1A45 81 DUP2 1A46 90 SWAP1 1A47 55 SSTORE 1A48 50 POP 1A49 30 ADDRESS 1A4A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A5F 16 AND 1A60 84 DUP5 1A61 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A76 16 AND 1A77 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1A98 83 DUP4 1A99 60 PUSH1 0x40 1A9B 51 MLOAD 1A9C 61 PUSH2 0x1aa5 1A9F 91 SWAP2 1AA0 90 SWAP1 1AA1 61 PUSH2 0x224d 1AA4 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1A38 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @1A3E memory[0x20:0x40] = 0x05 // @1A47 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1A5F stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @1A76 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1A77 stack[1] = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef // @1A9F stack[2] = 0x1aa5 // @1AA0 stack[3] = stack[-2] // @1AA0 stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x224d, returns to 0x1AA5 label_1AA5: // Incoming return from call to 0x224D at 0x1AA4 // Inputs[8] // { // @1AA8 memory[0x40:0x60] // @1AAA stack[-1] // @1AAD stack[-3] // @1AAD memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1AAD stack[-4] // @1AAD stack[-2] // @1AB1 stack[-5] // @1AB2 stack[-7] // } 1AA5 5B JUMPDEST 1AA6 60 PUSH1 0x40 1AA8 51 MLOAD 1AA9 80 DUP1 1AAA 91 SWAP2 1AAB 03 SUB 1AAC 90 SWAP1 1AAD A3 LOG3 1AAE 61 PUSH2 0x1ac0 1AB1 81 DUP2 1AB2 84 DUP5 1AB3 61 PUSH2 0x1bec 1AB6 90 SWAP1 1AB7 91 SWAP2 1AB8 90 SWAP1 1AB9 63 PUSH4 0xffffffff 1ABE 16 AND 1ABF 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1AAD log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); // @1AAE stack[-4] = 0x1ac0 // @1AB7 stack[-3] = stack[-7] // @1AB8 stack[-2] = stack[-5] // } // Block ends with call to 0xffffffff & 0x1bec, returns to 0x1AC0 label_1AC0: // Incoming return from call to 0x1BEC at 0x1ABF // Inputs[4] // { // @1AC1 stack[-1] // @1AC1 stack[-3] // @1AC4 stack[-6] // @1AC5 stack[-5] // } 1AC0 5B JUMPDEST 1AC1 91 SWAP2 1AC2 50 POP 1AC3 50 POP 1AC4 92 SWAP3 1AC5 91 SWAP2 1AC6 50 POP 1AC7 50 POP 1AC8 56 *JUMP // Stack delta = -5 // Outputs[1] { @1AC4 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1AC9: // Incoming call from 0x1A04, returns to 0x1A05 // Incoming call from 0x1074, returns to 0x1075 // Incoming call from 0x1249, returns to 0x124A // Inputs[2] // { // @1ACD stack[-1] // @1ACE stack[-2] // } 1AC9 5B JUMPDEST 1ACA 60 PUSH1 0x00 1ACC 80 DUP1 1ACD 82 DUP3 1ACE 84 DUP5 1ACF 61 PUSH2 0x1ad8 1AD2 91 SWAP2 1AD3 90 SWAP1 1AD4 61 PUSH2 0x2366 1AD7 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1ACA stack[0] = 0x00 // @1ACC stack[1] = 0x00 // @1AD2 stack[2] = 0x1ad8 // @1AD3 stack[3] = stack[-1] // @1AD3 stack[4] = stack[-2] // } // Block ends with call to 0x2366, returns to 0x1AD8 label_1AD8: // Incoming return from call to 0x2366 at 0x1AD7 // Inputs[3] // { // @1AD9 stack[-1] // @1AD9 stack[-2] // @1ADB stack[-5] // } 1AD8 5B JUMPDEST 1AD9 90 SWAP1 1ADA 50 POP 1ADB 83 DUP4 1ADC 81 DUP2 1ADD 10 LT 1ADE 15 ISZERO 1ADF 61 PUSH2 0x1b1d 1AE2 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1AD9 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1b1d, if !(stack[-1] < stack[-5]) label_1AE3: // Incoming jump from 0x1AE2, if not !(stack[-1] < stack[-5]) // Inputs[1] { @1AE5 memory[0x40:0x60] } 1AE3 60 PUSH1 0x40 1AE5 51 MLOAD 1AE6 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1B07 81 DUP2 1B08 52 MSTORE 1B09 60 PUSH1 0x04 1B0B 01 ADD 1B0C 61 PUSH2 0x1b14 1B0F 90 SWAP1 1B10 61 PUSH2 0x21cd 1B13 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B08 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1B0F stack[0] = 0x1b14 // @1B0F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x21cd, returns to 0x1B14 label_1B14: // Incoming return from call to 0x21CD at 0x1B13 // Inputs[3] // { // @1B17 memory[0x40:0x60] // @1B19 stack[-1] // @1B1C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1B14 5B JUMPDEST 1B15 60 PUSH1 0x40 1B17 51 MLOAD 1B18 80 DUP1 1B19 91 SWAP2 1B1A 03 SUB 1B1B 90 SWAP1 1B1C FD *REVERT // Stack delta = -1 // Outputs[1] { @1B1C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1B1D: // Incoming jump from 0x1AE2, if !(stack[-1] < stack[-5]) // Inputs[4] // { // @1B1E stack[-1] // @1B1F stack[-2] // @1B22 stack[-5] // @1B23 stack[-4] // } 1B1D 5B JUMPDEST 1B1E 80 DUP1 1B1F 91 SWAP2 1B20 50 POP 1B21 50 POP 1B22 92 SWAP3 1B23 91 SWAP2 1B24 50 POP 1B25 50 POP 1B26 56 *JUMP // Stack delta = -4 // Outputs[1] { @1B22 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1B27: // Incoming call from 0x1710, returns to 0x1711 // Incoming call from 0x1417, returns to 0x1418 // Incoming call from 0x19A2, returns to 0x19A3 // Incoming call from 0x16D7, returns to 0x16D8 // Inputs[1] { @1B2B stack[-2] } 1B27 5B JUMPDEST 1B28 60 PUSH1 0x00 1B2A 80 DUP1 1B2B 83 DUP4 1B2C 14 EQ 1B2D 15 ISZERO 1B2E 61 PUSH2 0x1b3a 1B31 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B28 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b3a, if !(stack[-2] == 0x00) label_1B32: // Incoming jump from 0x1B31, if not !(stack[-2] == 0x00) // Inputs[1] { @1B34 stack[-1] } 1B32 60 PUSH1 0x00 1B34 90 SWAP1 1B35 50 POP 1B36 61 PUSH2 0x1b9c 1B39 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B34 stack[-1] = 0x00 } // Block ends with unconditional jump to 0x1b9c label_1B3A: // Incoming jump from 0x1B31, if !(stack[-2] == 0x00) // Inputs[2] // { // @1B3D stack[-2] // @1B3E stack[-3] // } 1B3A 5B JUMPDEST 1B3B 60 PUSH1 0x00 1B3D 82 DUP3 1B3E 84 DUP5 1B3F 61 PUSH2 0x1b48 1B42 91 SWAP2 1B43 90 SWAP1 1B44 61 PUSH2 0x23ed 1B47 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B3B stack[0] = 0x00 // @1B42 stack[1] = 0x1b48 // @1B43 stack[2] = stack[-2] // @1B43 stack[3] = stack[-3] // } // Block ends with call to 0x23ed, returns to 0x1B48 label_1B48: // Incoming return from call to 0x23ED at 0x1B47 // Inputs[4] // { // @1B49 stack[-1] // @1B49 stack[-2] // @1B4B stack[-4] // @1B4C stack[-5] // } 1B48 5B JUMPDEST 1B49 90 SWAP1 1B4A 50 POP 1B4B 82 DUP3 1B4C 84 DUP5 1B4D 82 DUP3 1B4E 61 PUSH2 0x1b57 1B51 91 SWAP2 1B52 90 SWAP1 1B53 61 PUSH2 0x23bc 1B56 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1B49 stack[-2] = stack[-1] // @1B4B stack[-1] = stack[-4] // @1B51 stack[0] = 0x1b57 // @1B52 stack[1] = stack[-5] // @1B52 stack[2] = stack[-1] // } // Block ends with call to 0x23bc, returns to 0x1B57 label_1B57: // Incoming return from call to 0x23BC at 0x1B56 // Inputs[2] // { // @1B58 stack[-2] // @1B58 stack[-1] // } 1B57 5B JUMPDEST 1B58 14 EQ 1B59 61 PUSH2 0x1b97 1B5C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1b97, if stack[-1] == stack[-2] label_1B5D: // Incoming jump from 0x1B5C, if not stack[-1] == stack[-2] // Inputs[1] { @1B5F memory[0x40:0x60] } 1B5D 60 PUSH1 0x40 1B5F 51 MLOAD 1B60 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1B81 81 DUP2 1B82 52 MSTORE 1B83 60 PUSH1 0x04 1B85 01 ADD 1B86 61 PUSH2 0x1b8e 1B89 90 SWAP1 1B8A 61 PUSH2 0x220d 1B8D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B82 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1B89 stack[0] = 0x1b8e // @1B89 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x220d, returns to 0x1B8E label_1B8E: // Incoming return from call to 0x220D at 0x1B8D // Inputs[3] // { // @1B91 memory[0x40:0x60] // @1B93 stack[-1] // @1B96 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1B8E 5B JUMPDEST 1B8F 60 PUSH1 0x40 1B91 51 MLOAD 1B92 80 DUP1 1B93 91 SWAP2 1B94 03 SUB 1B95 90 SWAP1 1B96 FD *REVERT // Stack delta = -1 // Outputs[1] { @1B96 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1B97: // Incoming jump from 0x1B5C, if stack[-1] == stack[-2] // Inputs[2] // { // @1B98 stack[-1] // @1B99 stack[-2] // } 1B97 5B JUMPDEST 1B98 80 DUP1 1B99 91 SWAP2 1B9A 50 POP 1B9B 50 POP // Stack delta = -1 // Outputs[1] { @1B99 stack[-2] = stack[-1] } // Block continues label_1B9C: // Incoming jump from 0x1B39 // Incoming jump from 0x1B9B // Inputs[3] // { // @1B9D stack[-1] // @1B9D stack[-4] // @1B9E stack[-3] // } 1B9C 5B JUMPDEST 1B9D 92 SWAP3 1B9E 91 SWAP2 1B9F 50 POP 1BA0 50 POP 1BA1 56 *JUMP // Stack delta = -3 // Outputs[1] { @1B9D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1BA2: // Incoming jump from 0x1425 // Incoming call from 0x16A4, returns to 0x16A5 // Incoming jump from 0x16E5 // Incoming jump from 0x171E // Incoming jump from 0x16F3 // Incoming jump from 0x19B0 // Incoming jump from 0x1433 // Inputs[3] // { // @1BA8 stack[-2] // @1BA9 stack[-1] // @1BAC memory[0x40:0x60] // } 1BA2 5B JUMPDEST 1BA3 60 PUSH1 0x00 1BA5 61 PUSH2 0x1be4 1BA8 83 DUP4 1BA9 83 DUP4 1BAA 60 PUSH1 0x40 1BAC 51 MLOAD 1BAD 80 DUP1 1BAE 60 PUSH1 0x40 1BB0 01 ADD 1BB1 60 PUSH1 0x40 1BB3 52 MSTORE 1BB4 80 DUP1 1BB5 60 PUSH1 0x1a 1BB7 81 DUP2 1BB8 52 MSTORE 1BB9 60 PUSH1 0x20 1BBB 01 ADD 1BBC 7F PUSH32 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000 1BDD 81 DUP2 1BDE 52 MSTORE 1BDF 50 POP 1BE0 61 PUSH2 0x1c36 1BE3 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @1BA3 stack[0] = 0x00 // @1BA5 stack[1] = 0x1be4 // @1BA8 stack[2] = stack[-2] // @1BA9 stack[3] = stack[-1] // @1BAC stack[4] = memory[0x40:0x60] // @1BB3 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1BB8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1a // @1BDE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000 // } // Block ends with call to 0x1c36, returns to 0x1BE4 label_1BE4: // Incoming return from call to 0x1C36 at 0x1BE3 // Inputs[4] // { // @1BE5 stack[-2] // @1BE5 stack[-1] // @1BE7 stack[-5] // @1BE8 stack[-4] // } 1BE4 5B JUMPDEST 1BE5 90 SWAP1 1BE6 50 POP 1BE7 92 SWAP3 1BE8 91 SWAP2 1BE9 50 POP 1BEA 50 POP 1BEB 56 *JUMP // Stack delta = -4 // Outputs[1] { @1BE7 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1BEC: // Incoming call from 0x1ABF, returns to 0x1AC0 // Incoming call from 0x1687, returns to 0x1688 // Incoming jump from 0x16B5 // Incoming call from 0x144A, returns to 0x144B // Inputs[3] // { // @1BF2 stack[-2] // @1BF3 stack[-1] // @1BF6 memory[0x40:0x60] // } 1BEC 5B JUMPDEST 1BED 60 PUSH1 0x00 1BEF 61 PUSH2 0x1c2e 1BF2 83 DUP4 1BF3 83 DUP4 1BF4 60 PUSH1 0x40 1BF6 51 MLOAD 1BF7 80 DUP1 1BF8 60 PUSH1 0x40 1BFA 01 ADD 1BFB 60 PUSH1 0x40 1BFD 52 MSTORE 1BFE 80 DUP1 1BFF 60 PUSH1 0x1e 1C01 81 DUP2 1C02 52 MSTORE 1C03 60 PUSH1 0x20 1C05 01 ADD 1C06 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 1C27 81 DUP2 1C28 52 MSTORE 1C29 50 POP 1C2A 61 PUSH2 0x0cfd 1C2D 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @1BED stack[0] = 0x00 // @1BEF stack[1] = 0x1c2e // @1BF2 stack[2] = stack[-2] // @1BF3 stack[3] = stack[-1] // @1BF6 stack[4] = memory[0x40:0x60] // @1BFD memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1C02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e // @1C28 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // } // Block ends with call to 0x0cfd, returns to 0x1C2E label_1C2E: // Incoming return from call to 0x0CFD at 0x1C2D // Inputs[4] // { // @1C2F stack[-2] // @1C2F stack[-1] // @1C31 stack[-5] // @1C32 stack[-4] // } 1C2E 5B JUMPDEST 1C2F 90 SWAP1 1C30 50 POP 1C31 92 SWAP3 1C32 91 SWAP2 1C33 50 POP 1C34 50 POP 1C35 56 *JUMP // Stack delta = -4 // Outputs[1] { @1C31 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1C36: // Incoming call from 0x1BE3, returns to 0x1BE4 // Inputs[2] // { // @1C3A stack[-2] // @1C3C stack[-1] // } 1C36 5B JUMPDEST 1C37 60 PUSH1 0x00 1C39 80 DUP1 1C3A 83 DUP4 1C3B 11 GT 1C3C 82 DUP3 1C3D 90 SWAP1 1C3E 61 PUSH2 0x1c7d 1C41 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C37 stack[0] = 0x00 // @1C3D stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1c7d, if stack[-2] > 0x00 label_1C42: // Incoming jump from 0x1C41, if not stack[-2] > 0x00 // Inputs[2] // { // @1C44 memory[0x40:0x60] // @1C6E stack[-1] // } 1C42 60 PUSH1 0x40 1C44 51 MLOAD 1C45 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1C66 81 DUP2 1C67 52 MSTORE 1C68 60 PUSH1 0x04 1C6A 01 ADD 1C6B 61 PUSH2 0x1c74 1C6E 91 SWAP2 1C6F 90 SWAP1 1C70 61 PUSH2 0x218b 1C73 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1C67 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1C6E stack[-1] = 0x1c74 // @1C6F stack[1] = 0x04 + memory[0x40:0x60] // @1C6F stack[0] = stack[-1] // } // Block ends with call to 0x218b, returns to 0x1C74 label_1C74: // Incoming return from call to 0x218B at 0x1C73 // Inputs[3] // { // @1C77 memory[0x40:0x60] // @1C79 stack[-1] // @1C7C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1C74 5B JUMPDEST 1C75 60 PUSH1 0x40 1C77 51 MLOAD 1C78 80 DUP1 1C79 91 SWAP2 1C7A 03 SUB 1C7B 90 SWAP1 1C7C FD *REVERT // Stack delta = -1 // Outputs[1] { @1C7C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1C7D: // Incoming jump from 0x1C41, if stack[-2] > 0x00 // Inputs[2] // { // @1C81 stack[-4] // @1C82 stack[-5] // } 1C7D 5B JUMPDEST 1C7E 50 POP 1C7F 60 PUSH1 0x00 1C81 83 DUP4 1C82 85 DUP6 1C83 61 PUSH2 0x1c8c 1C86 91 SWAP2 1C87 90 SWAP1 1C88 61 PUSH2 0x23bc 1C8B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1C7F stack[-1] = 0x00 // @1C86 stack[0] = 0x1c8c // @1C87 stack[2] = stack[-5] // @1C87 stack[1] = stack[-4] // } // Block ends with call to 0x23bc, returns to 0x1C8C label_1C8C: // Incoming return from call to 0x23BC at 0x1C8B // Inputs[5] // { // @1C8D stack[-2] // @1C8D stack[-1] // @1C90 stack[-3] // @1C93 stack[-7] // @1C94 stack[-6] // } 1C8C 5B JUMPDEST 1C8D 90 SWAP1 1C8E 50 POP 1C8F 80 DUP1 1C90 91 SWAP2 1C91 50 POP 1C92 50 POP 1C93 93 SWAP4 1C94 92 SWAP3 1C95 50 POP 1C96 50 POP 1C97 50 POP 1C98 56 *JUMP // Stack delta = -6 // Outputs[1] { @1C93 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_1C99: // Incoming call from 0x1D6B, returns to 0x1D6C // Incoming call from 0x1D10, returns to 0x1D11 // Incoming call from 0x1DFE, returns to 0x1DFF // Incoming call from 0x1DBE, returns to 0x1DBF // Incoming call from 0x1DAD, returns to 0x1DAE // Incoming call from 0x1D7C, returns to 0x1D7D // Inputs[2] // { // @1C9C stack[-1] // @1C9D msg.data[stack[-1]:stack[-1] + 0x20] // } 1C99 5B JUMPDEST 1C9A 60 PUSH1 0x00 1C9C 81 DUP2 1C9D 35 CALLDATALOAD 1C9E 90 SWAP1 1C9F 50 POP 1CA0 61 PUSH2 0x1ca8 1CA3 81 DUP2 1CA4 61 PUSH2 0x2727 1CA7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C9E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1CA0 stack[1] = 0x1ca8 // @1CA3 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2727, returns to 0x1CA8 label_1CA8: // Incoming return from call to 0x2727 at 0x1CA7 // Inputs[3] // { // @1CA9 stack[-1] // @1CA9 stack[-4] // @1CAA stack[-3] // } 1CA8 5B JUMPDEST 1CA9 92 SWAP3 1CAA 91 SWAP2 1CAB 50 POP 1CAC 50 POP 1CAD 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CA9 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1CAE: // Incoming call from 0x1D3D, returns to 0x1D3E // Inputs[2] // { // @1CB1 stack[-1] // @1CB2 memory[stack[-1]:stack[-1] + 0x20] // } 1CAE 5B JUMPDEST 1CAF 60 PUSH1 0x00 1CB1 81 DUP2 1CB2 51 MLOAD 1CB3 90 SWAP1 1CB4 50 POP 1CB5 61 PUSH2 0x1cbd 1CB8 81 DUP2 1CB9 61 PUSH2 0x2727 1CBC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CB3 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @1CB5 stack[1] = 0x1cbd // @1CB8 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2727, returns to 0x1CBD label_1CBD: // Incoming return from call to 0x2727 at 0x1CBC // Inputs[3] // { // @1CBE stack[-1] // @1CBE stack[-4] // @1CBF stack[-3] // } 1CBD 5B JUMPDEST 1CBE 92 SWAP3 1CBF 91 SWAP2 1CC0 50 POP 1CC1 50 POP 1CC2 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CBE stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1CC3: // Incoming call from 0x1E0F, returns to 0x1E10 // Incoming call from 0x1E3D, returns to 0x1E3E // Incoming call from 0x1DCF, returns to 0x1DD0 // Incoming call from 0x1E6B, returns to 0x1E6C // Incoming call from 0x1E7C, returns to 0x1E7D // Inputs[2] // { // @1CC6 stack[-1] // @1CC7 msg.data[stack[-1]:stack[-1] + 0x20] // } 1CC3 5B JUMPDEST 1CC4 60 PUSH1 0x00 1CC6 81 DUP2 1CC7 35 CALLDATALOAD 1CC8 90 SWAP1 1CC9 50 POP 1CCA 61 PUSH2 0x1cd2 1CCD 81 DUP2 1CCE 61 PUSH2 0x273e 1CD1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CC8 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1CCA stack[1] = 0x1cd2 // @1CCD stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x273e, returns to 0x1CD2 label_1CD2: // Incoming return from call to 0x273E at 0x1CD1 // Inputs[3] // { // @1CD3 stack[-4] // @1CD3 stack[-1] // @1CD4 stack[-3] // } 1CD2 5B JUMPDEST 1CD3 92 SWAP3 1CD4 91 SWAP2 1CD5 50 POP 1CD6 50 POP 1CD7 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CD3 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1CD8: // Incoming call from 0x1ECF, returns to 0x1ED0 // Incoming call from 0x1EAD, returns to 0x1EAE // Incoming call from 0x1EBE, returns to 0x1EBF // Inputs[2] // { // @1CDB stack[-1] // @1CDC memory[stack[-1]:stack[-1] + 0x20] // } 1CD8 5B JUMPDEST 1CD9 60 PUSH1 0x00 1CDB 81 DUP2 1CDC 51 MLOAD 1CDD 90 SWAP1 1CDE 50 POP 1CDF 61 PUSH2 0x1ce7 1CE2 81 DUP2 1CE3 61 PUSH2 0x273e 1CE6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CDD stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @1CDF stack[1] = 0x1ce7 // @1CE2 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x273e, returns to 0x1CE7 label_1CE7: // Incoming return from call to 0x273E at 0x1CE6 // Inputs[3] // { // @1CE8 stack[-1] // @1CE8 stack[-4] // @1CE9 stack[-3] // } 1CE7 5B JUMPDEST 1CE8 92 SWAP3 1CE9 91 SWAP2 1CEA 50 POP 1CEB 50 POP 1CEC 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CE8 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1CED: // Incoming call from 0x039C, returns to 0x039D // Incoming call from 0x0309, returns to 0x030A // Incoming call from 0x0261, returns to 0x0262 // Inputs[2] // { // @1CF2 stack[-1] // @1CF3 stack[-2] // } 1CED 5B JUMPDEST 1CEE 60 PUSH1 0x00 1CF0 60 PUSH1 0x20 1CF2 82 DUP3 1CF3 84 DUP5 1CF4 03 SUB 1CF5 12 SLT 1CF6 15 ISZERO 1CF7 61 PUSH2 0x1d03 1CFA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CEE stack[0] = 0x00 } // Block ends with conditional jump to 0x1d03, if !(stack[-2] - stack[-1] i< 0x20) label_1CFB: // Incoming jump from 0x1CFA, if not !(stack[-2] - stack[-1] i< 0x20) 1CFB 61 PUSH2 0x1d02 1CFE 61 PUSH2 0x25f5 1D01 56 *JUMP // Stack delta = +1 // Outputs[1] { @1CFB stack[0] = 0x1d02 } // Block ends with unconditional jump to 0x25f5 1D02 5B JUMPDEST label_1D03: // Incoming jump from 0x1CFA, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D09 stack[-3] // @1D0B stack[-2] // } 1D03 5B JUMPDEST 1D04 60 PUSH1 0x00 1D06 61 PUSH2 0x1d11 1D09 84 DUP5 1D0A 82 DUP3 1D0B 85 DUP6 1D0C 01 ADD 1D0D 61 PUSH2 0x1c99 1D10 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D04 stack[0] = 0x00 // @1D06 stack[1] = 0x1d11 // @1D09 stack[2] = stack[-3] // @1D0C stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1c99, returns to 0x1D11 label_1D11: // Incoming return from call to 0x1C99 at 0x1D10 // Inputs[4] // { // @1D12 stack[-3] // @1D12 stack[-1] // @1D15 stack[-6] // @1D16 stack[-5] // } 1D11 5B JUMPDEST 1D12 91 SWAP2 1D13 50 POP 1D14 50 POP 1D15 92 SWAP3 1D16 91 SWAP2 1D17 50 POP 1D18 50 POP 1D19 56 *JUMP // Stack delta = -5 // Outputs[1] { @1D15 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1D1A: // Incoming call from 0x1589, returns to 0x158A // Inputs[2] // { // @1D1F stack[-1] // @1D20 stack[-2] // } 1D1A 5B JUMPDEST 1D1B 60 PUSH1 0x00 1D1D 60 PUSH1 0x20 1D1F 82 DUP3 1D20 84 DUP5 1D21 03 SUB 1D22 12 SLT 1D23 15 ISZERO 1D24 61 PUSH2 0x1d30 1D27 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D1B stack[0] = 0x00 } // Block ends with conditional jump to 0x1d30, if !(stack[-2] - stack[-1] i< 0x20) label_1D28: // Incoming jump from 0x1D27, if not !(stack[-2] - stack[-1] i< 0x20) 1D28 61 PUSH2 0x1d2f 1D2B 61 PUSH2 0x25f5 1D2E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D28 stack[0] = 0x1d2f } // Block ends with unconditional jump to 0x25f5 1D2F 5B JUMPDEST label_1D30: // Incoming jump from 0x1D27, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D36 stack[-3] // @1D38 stack[-2] // } 1D30 5B JUMPDEST 1D31 60 PUSH1 0x00 1D33 61 PUSH2 0x1d3e 1D36 84 DUP5 1D37 82 DUP3 1D38 85 DUP6 1D39 01 ADD 1D3A 61 PUSH2 0x1cae 1D3D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D31 stack[0] = 0x00 // @1D33 stack[1] = 0x1d3e // @1D36 stack[2] = stack[-3] // @1D39 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1cae, returns to 0x1D3E label_1D3E: // Incoming return from call to 0x1CAE at 0x1D3D // Inputs[4] // { // @1D3F stack[-1] // @1D3F stack[-3] // @1D42 stack[-6] // @1D43 stack[-5] // } 1D3E 5B JUMPDEST 1D3F 91 SWAP2 1D40 50 POP 1D41 50 POP 1D42 92 SWAP3 1D43 91 SWAP2 1D44 50 POP 1D45 50 POP 1D46 56 *JUMP // Stack delta = -5 // Outputs[1] { @1D42 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1D47: // Incoming call from 0x04AE, returns to 0x04AF // Inputs[2] // { // @1D4D stack[-1] // @1D4E stack[-2] // } 1D47 5B JUMPDEST 1D48 60 PUSH1 0x00 1D4A 80 DUP1 1D4B 60 PUSH1 0x40 1D4D 83 DUP4 1D4E 85 DUP6 1D4F 03 SUB 1D50 12 SLT 1D51 15 ISZERO 1D52 61 PUSH2 0x1d5e 1D55 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D48 stack[0] = 0x00 // @1D4A stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d5e, if !(stack[-2] - stack[-1] i< 0x40) label_1D56: // Incoming jump from 0x1D55, if not !(stack[-2] - stack[-1] i< 0x40) 1D56 61 PUSH2 0x1d5d 1D59 61 PUSH2 0x25f5 1D5C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D56 stack[0] = 0x1d5d } // Block ends with unconditional jump to 0x25f5 1D5D 5B JUMPDEST label_1D5E: // Incoming jump from 0x1D55, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D64 stack[-4] // @1D66 stack[-3] // } 1D5E 5B JUMPDEST 1D5F 60 PUSH1 0x00 1D61 61 PUSH2 0x1d6c 1D64 85 DUP6 1D65 82 DUP3 1D66 86 DUP7 1D67 01 ADD 1D68 61 PUSH2 0x1c99 1D6B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D5F stack[0] = 0x00 // @1D61 stack[1] = 0x1d6c // @1D64 stack[2] = stack[-4] // @1D67 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x1c99, returns to 0x1D6C label_1D6C: // Incoming return from call to 0x1C99 at 0x1D6B // Inputs[4] // { // @1D6D stack[-1] // @1D6D stack[-4] // @1D75 stack[-6] // @1D77 stack[-5] // } 1D6C 5B JUMPDEST 1D6D 92 SWAP3 1D6E 50 POP 1D6F 50 POP 1D70 60 PUSH1 0x20 1D72 61 PUSH2 0x1d7d 1D75 85 DUP6 1D76 82 DUP3 1D77 86 DUP7 1D78 01 ADD 1D79 61 PUSH2 0x1c99 1D7C 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1D6D stack[-4] = stack[-1] // @1D70 stack[-2] = 0x20 // @1D72 stack[-1] = 0x1d7d // @1D75 stack[0] = stack[-6] // @1D78 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1c99, returns to 0x1D7D label_1D7D: // Incoming return from call to 0x1C99 at 0x1D7C // Inputs[6] // { // @1D7E stack[-1] // @1D7E stack[-3] // @1D81 stack[-6] // @1D83 stack[-4] // @1D83 stack[-7] // @1D84 stack[-5] // } 1D7D 5B JUMPDEST 1D7E 91 SWAP2 1D7F 50 POP 1D80 50 POP 1D81 92 SWAP3 1D82 50 POP 1D83 92 SWAP3 1D84 90 SWAP1 1D85 50 POP 1D86 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1D81 stack[-6] = stack[-1] // @1D83 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1D87: // Incoming call from 0x0224, returns to 0x0225 // Inputs[2] // { // @1D8F stack[-1] // @1D90 stack[-2] // } 1D87 5B JUMPDEST 1D88 60 PUSH1 0x00 1D8A 80 DUP1 1D8B 60 PUSH1 0x00 1D8D 60 PUSH1 0x60 1D8F 84 DUP5 1D90 86 DUP7 1D91 03 SUB 1D92 12 SLT 1D93 15 ISZERO 1D94 61 PUSH2 0x1da0 1D97 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1D88 stack[0] = 0x00 // @1D8A stack[1] = 0x00 // @1D8B stack[2] = 0x00 // } // Block ends with conditional jump to 0x1da0, if !(stack[-2] - stack[-1] i< 0x60) label_1D98: // Incoming jump from 0x1D97, if not !(stack[-2] - stack[-1] i< 0x60) 1D98 61 PUSH2 0x1d9f 1D9B 61 PUSH2 0x25f5 1D9E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D98 stack[0] = 0x1d9f } // Block ends with unconditional jump to 0x25f5 1D9F 5B JUMPDEST label_1DA0: // Incoming jump from 0x1D97, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1DA6 stack[-5] // @1DA8 stack[-4] // } 1DA0 5B JUMPDEST 1DA1 60 PUSH1 0x00 1DA3 61 PUSH2 0x1dae 1DA6 86 DUP7 1DA7 82 DUP3 1DA8 87 DUP8 1DA9 01 ADD 1DAA 61 PUSH2 0x1c99 1DAD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DA1 stack[0] = 0x00 // @1DA3 stack[1] = 0x1dae // @1DA6 stack[2] = stack[-5] // @1DA9 stack[3] = stack[-4] + 0x00 // } // Block ends with call to 0x1c99, returns to 0x1DAE label_1DAE: // Incoming return from call to 0x1C99 at 0x1DAD // Inputs[4] // { // @1DAF stack[-1] // @1DAF stack[-5] // @1DB7 stack[-7] // @1DB9 stack[-6] // } 1DAE 5B JUMPDEST 1DAF 93 SWAP4 1DB0 50 POP 1DB1 50 POP 1DB2 60 PUSH1 0x20 1DB4 61 PUSH2 0x1dbf 1DB7 86 DUP7 1DB8 82 DUP3 1DB9 87 DUP8 1DBA 01 ADD 1DBB 61 PUSH2 0x1c99 1DBE 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1DAF stack[-5] = stack[-1] // @1DB2 stack[-2] = 0x20 // @1DB4 stack[-1] = 0x1dbf // @1DB7 stack[0] = stack[-7] // @1DBA stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x1c99, returns to 0x1DBF label_1DBF: // Incoming return from call to 0x1C99 at 0x1DBE // Inputs[4] // { // @1DC0 stack[-1] // @1DC0 stack[-4] // @1DC8 stack[-7] // @1DCA stack[-6] // } 1DBF 5B JUMPDEST 1DC0 92 SWAP3 1DC1 50 POP 1DC2 50 POP 1DC3 60 PUSH1 0x40 1DC5 61 PUSH2 0x1dd0 1DC8 86 DUP7 1DC9 82 DUP3 1DCA 87 DUP8 1DCB 01 ADD 1DCC 61 PUSH2 0x1cc3 1DCF 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1DC0 stack[-4] = stack[-1] // @1DC3 stack[-2] = 0x40 // @1DC5 stack[-1] = 0x1dd0 // @1DC8 stack[0] = stack[-7] // @1DCB stack[1] = stack[-6] + 0x40 // } // Block ends with call to 0x1cc3, returns to 0x1DD0 label_1DD0: // Incoming return from call to 0x1CC3 at 0x1DCF // Inputs[7] // { // @1DD1 stack[-1] // @1DD1 stack[-3] // @1DD4 stack[-6] // @1DD6 stack[-7] // @1DD6 stack[-4] // @1DD8 stack[-8] // @1DD8 stack[-5] // } 1DD0 5B JUMPDEST 1DD1 91 SWAP2 1DD2 50 POP 1DD3 50 POP 1DD4 92 SWAP3 1DD5 50 POP 1DD6 92 SWAP3 1DD7 50 POP 1DD8 92 SWAP3 1DD9 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1DD4 stack[-6] = stack[-1] // @1DD6 stack[-7] = stack[-4] // @1DD8 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_1DDA: // Incoming call from 0x0471, returns to 0x0472 // Incoming call from 0x01BC, returns to 0x01BD // Inputs[2] // { // @1DE0 stack[-1] // @1DE1 stack[-2] // } 1DDA 5B JUMPDEST 1DDB 60 PUSH1 0x00 1DDD 80 DUP1 1DDE 60 PUSH1 0x40 1DE0 83 DUP4 1DE1 85 DUP6 1DE2 03 SUB 1DE3 12 SLT 1DE4 15 ISZERO 1DE5 61 PUSH2 0x1df1 1DE8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DDB stack[0] = 0x00 // @1DDD stack[1] = 0x00 // } // Block ends with conditional jump to 0x1df1, if !(stack[-2] - stack[-1] i< 0x40) label_1DE9: // Incoming jump from 0x1DE8, if not !(stack[-2] - stack[-1] i< 0x40) 1DE9 61 PUSH2 0x1df0 1DEC 61 PUSH2 0x25f5 1DEF 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DE9 stack[0] = 0x1df0 } // Block ends with unconditional jump to 0x25f5 1DF0 5B JUMPDEST label_1DF1: // Incoming jump from 0x1DE8, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1DF7 stack[-4] // @1DF9 stack[-3] // } 1DF1 5B JUMPDEST 1DF2 60 PUSH1 0x00 1DF4 61 PUSH2 0x1dff 1DF7 85 DUP6 1DF8 82 DUP3 1DF9 86 DUP7 1DFA 01 ADD 1DFB 61 PUSH2 0x1c99 1DFE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DF2 stack[0] = 0x00 // @1DF4 stack[1] = 0x1dff // @1DF7 stack[2] = stack[-4] // @1DFA stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x1c99, returns to 0x1DFF label_1DFF: // Incoming return from call to 0x1C99 at 0x1DFE // Inputs[4] // { // @1E00 stack[-1] // @1E00 stack[-4] // @1E08 stack[-6] // @1E0A stack[-5] // } 1DFF 5B JUMPDEST 1E00 92 SWAP3 1E01 50 POP 1E02 50 POP 1E03 60 PUSH1 0x20 1E05 61 PUSH2 0x1e10 1E08 85 DUP6 1E09 82 DUP3 1E0A 86 DUP7 1E0B 01 ADD 1E0C 61 PUSH2 0x1cc3 1E0F 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1E00 stack[-4] = stack[-1] // @1E03 stack[-2] = 0x20 // @1E05 stack[-1] = 0x1e10 // @1E08 stack[0] = stack[-6] // @1E0B stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1cc3, returns to 0x1E10 label_1E10: // Incoming return from call to 0x1CC3 at 0x1E0F // Inputs[6] // { // @1E11 stack[-1] // @1E11 stack[-3] // @1E14 stack[-6] // @1E16 stack[-7] // @1E16 stack[-4] // @1E17 stack[-5] // } 1E10 5B JUMPDEST 1E11 91 SWAP2 1E12 50 POP 1E13 50 POP 1E14 92 SWAP3 1E15 50 POP 1E16 92 SWAP3 1E17 90 SWAP1 1E18 50 POP 1E19 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1E14 stack[-6] = stack[-1] // @1E16 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1E1A: // Incoming call from 0x0516, returns to 0x0517 // Inputs[2] // { // @1E1F stack[-1] // @1E20 stack[-2] // } 1E1A 5B JUMPDEST 1E1B 60 PUSH1 0x00 1E1D 60 PUSH1 0x20 1E1F 82 DUP3 1E20 84 DUP5 1E21 03 SUB 1E22 12 SLT 1E23 15 ISZERO 1E24 61 PUSH2 0x1e30 1E27 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E1B stack[0] = 0x00 } // Block ends with conditional jump to 0x1e30, if !(stack[-2] - stack[-1] i< 0x20) label_1E28: // Incoming jump from 0x1E27, if not !(stack[-2] - stack[-1] i< 0x20) 1E28 61 PUSH2 0x1e2f 1E2B 61 PUSH2 0x25f5 1E2E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E28 stack[0] = 0x1e2f } // Block ends with unconditional jump to 0x25f5 1E2F 5B JUMPDEST label_1E30: // Incoming jump from 0x1E27, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E36 stack[-3] // @1E38 stack[-2] // } 1E30 5B JUMPDEST 1E31 60 PUSH1 0x00 1E33 61 PUSH2 0x1e3e 1E36 84 DUP5 1E37 82 DUP3 1E38 85 DUP6 1E39 01 ADD 1E3A 61 PUSH2 0x1cc3 1E3D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E31 stack[0] = 0x00 // @1E33 stack[1] = 0x1e3e // @1E36 stack[2] = stack[-3] // @1E39 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1cc3, returns to 0x1E3E label_1E3E: // Incoming return from call to 0x1CC3 at 0x1E3D // Inputs[4] // { // @1E3F stack[-1] // @1E3F stack[-3] // @1E42 stack[-6] // @1E43 stack[-5] // } 1E3E 5B JUMPDEST 1E3F 91 SWAP2 1E40 50 POP 1E41 50 POP 1E42 92 SWAP3 1E43 91 SWAP2 1E44 50 POP 1E45 50 POP 1E46 56 *JUMP // Stack delta = -5 // Outputs[1] { @1E42 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1E47: // Incoming call from 0x02E0, returns to 0x02E1 // Inputs[2] // { // @1E4D stack[-1] // @1E4E stack[-2] // } 1E47 5B JUMPDEST 1E48 60 PUSH1 0x00 1E4A 80 DUP1 1E4B 60 PUSH1 0x40 1E4D 83 DUP4 1E4E 85 DUP6 1E4F 03 SUB 1E50 12 SLT 1E51 15 ISZERO 1E52 61 PUSH2 0x1e5e 1E55 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E48 stack[0] = 0x00 // @1E4A stack[1] = 0x00 // } // Block ends with conditional jump to 0x1e5e, if !(stack[-2] - stack[-1] i< 0x40) label_1E56: // Incoming jump from 0x1E55, if not !(stack[-2] - stack[-1] i< 0x40) 1E56 61 PUSH2 0x1e5d 1E59 61 PUSH2 0x25f5 1E5C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E56 stack[0] = 0x1e5d } // Block ends with unconditional jump to 0x25f5 1E5D 5B JUMPDEST label_1E5E: // Incoming jump from 0x1E55, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1E64 stack[-4] // @1E66 stack[-3] // } 1E5E 5B JUMPDEST 1E5F 60 PUSH1 0x00 1E61 61 PUSH2 0x1e6c 1E64 85 DUP6 1E65 82 DUP3 1E66 86 DUP7 1E67 01 ADD 1E68 61 PUSH2 0x1cc3 1E6B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E5F stack[0] = 0x00 // @1E61 stack[1] = 0x1e6c // @1E64 stack[2] = stack[-4] // @1E67 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x1cc3, returns to 0x1E6C label_1E6C: // Incoming return from call to 0x1CC3 at 0x1E6B // Inputs[4] // { // @1E6D stack[-1] // @1E6D stack[-4] // @1E75 stack[-6] // @1E77 stack[-5] // } 1E6C 5B JUMPDEST 1E6D 92 SWAP3 1E6E 50 POP 1E6F 50 POP 1E70 60 PUSH1 0x20 1E72 61 PUSH2 0x1e7d 1E75 85 DUP6 1E76 82 DUP3 1E77 86 DUP7 1E78 01 ADD 1E79 61 PUSH2 0x1cc3 1E7C 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1E6D stack[-4] = stack[-1] // @1E70 stack[-2] = 0x20 // @1E72 stack[-1] = 0x1e7d // @1E75 stack[0] = stack[-6] // @1E78 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1cc3, returns to 0x1E7D label_1E7D: // Incoming return from call to 0x1CC3 at 0x1E7C // Inputs[6] // { // @1E7E stack[-1] // @1E7E stack[-3] // @1E81 stack[-6] // @1E83 stack[-7] // @1E83 stack[-4] // @1E84 stack[-5] // } 1E7D 5B JUMPDEST 1E7E 91 SWAP2 1E7F 50 POP 1E80 50 POP 1E81 92 SWAP3 1E82 50 POP 1E83 92 SWAP3 1E84 90 SWAP1 1E85 50 POP 1E86 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1E81 stack[-6] = stack[-1] // @1E83 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1E87: // Incoming call from 0x18C9, returns to 0x18CA // Inputs[2] // { // @1E8F stack[-1] // @1E90 stack[-2] // } 1E87 5B JUMPDEST 1E88 60 PUSH1 0x00 1E8A 80 DUP1 1E8B 60 PUSH1 0x00 1E8D 60 PUSH1 0x60 1E8F 84 DUP5 1E90 86 DUP7 1E91 03 SUB 1E92 12 SLT 1E93 15 ISZERO 1E94 61 PUSH2 0x1ea0 1E97 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1E88 stack[0] = 0x00 // @1E8A stack[1] = 0x00 // @1E8B stack[2] = 0x00 // } // Block ends with conditional jump to 0x1ea0, if !(stack[-2] - stack[-1] i< 0x60) label_1E98: // Incoming jump from 0x1E97, if not !(stack[-2] - stack[-1] i< 0x60) 1E98 61 PUSH2 0x1e9f 1E9B 61 PUSH2 0x25f5 1E9E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E98 stack[0] = 0x1e9f } // Block ends with unconditional jump to 0x25f5 1E9F 5B JUMPDEST label_1EA0: // Incoming jump from 0x1E97, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1EA6 stack[-5] // @1EA8 stack[-4] // } 1EA0 5B JUMPDEST 1EA1 60 PUSH1 0x00 1EA3 61 PUSH2 0x1eae 1EA6 86 DUP7 1EA7 82 DUP3 1EA8 87 DUP8 1EA9 01 ADD 1EAA 61 PUSH2 0x1cd8 1EAD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EA1 stack[0] = 0x00 // @1EA3 stack[1] = 0x1eae // @1EA6 stack[2] = stack[-5] // @1EA9 stack[3] = stack[-4] + 0x00 // } // Block ends with call to 0x1cd8, returns to 0x1EAE label_1EAE: // Incoming return from call to 0x1CD8 at 0x1EAD // Inputs[4] // { // @1EAF stack[-5] // @1EAF stack[-1] // @1EB7 stack[-7] // @1EB9 stack[-6] // } 1EAE 5B JUMPDEST 1EAF 93 SWAP4 1EB0 50 POP 1EB1 50 POP 1EB2 60 PUSH1 0x20 1EB4 61 PUSH2 0x1ebf 1EB7 86 DUP7 1EB8 82 DUP3 1EB9 87 DUP8 1EBA 01 ADD 1EBB 61 PUSH2 0x1cd8 1EBE 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1EAF stack[-5] = stack[-1] // @1EB2 stack[-2] = 0x20 // @1EB4 stack[-1] = 0x1ebf // @1EB7 stack[0] = stack[-7] // @1EBA stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x1cd8, returns to 0x1EBF label_1EBF: // Incoming return from call to 0x1CD8 at 0x1EBE // Inputs[4] // { // @1EC0 stack[-1] // @1EC0 stack[-4] // @1EC8 stack[-7] // @1ECA stack[-6] // } 1EBF 5B JUMPDEST 1EC0 92 SWAP3 1EC1 50 POP 1EC2 50 POP 1EC3 60 PUSH1 0x40 1EC5 61 PUSH2 0x1ed0 1EC8 86 DUP7 1EC9 82 DUP3 1ECA 87 DUP8 1ECB 01 ADD 1ECC 61 PUSH2 0x1cd8 1ECF 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1EC0 stack[-4] = stack[-1] // @1EC3 stack[-2] = 0x40 // @1EC5 stack[-1] = 0x1ed0 // @1EC8 stack[0] = stack[-7] // @1ECB stack[1] = stack[-6] + 0x40 // } // Block ends with call to 0x1cd8, returns to 0x1ED0 label_1ED0: // Incoming return from call to 0x1CD8 at 0x1ECF // Inputs[7] // { // @1ED1 stack[-1] // @1ED1 stack[-3] // @1ED4 stack[-6] // @1ED6 stack[-4] // @1ED6 stack[-7] // @1ED8 stack[-8] // @1ED8 stack[-5] // } 1ED0 5B JUMPDEST 1ED1 91 SWAP2 1ED2 50 POP 1ED3 50 POP 1ED4 92 SWAP3 1ED5 50 POP 1ED6 92 SWAP3 1ED7 50 POP 1ED8 92 SWAP3 1ED9 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1ED4 stack[-6] = stack[-1] // @1ED6 stack[-7] = stack[-4] // @1ED8 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_1EDA: // Incoming call from 0x1F47, returns to 0x1F48 // Inputs[2] // { // @1EE0 stack[-2] // @1EE1 stack[-1] // } 1EDA 5B JUMPDEST 1EDB 60 PUSH1 0x00 1EDD 61 PUSH2 0x1ee6 1EE0 83 DUP4 1EE1 83 DUP4 1EE2 61 PUSH2 0x1ef2 1EE5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EDB stack[0] = 0x00 // @1EDD stack[1] = 0x1ee6 // @1EE0 stack[2] = stack[-2] // @1EE1 stack[3] = stack[-1] // } // Block ends with call to 0x1ef2, returns to 0x1EE6 label_1EE6: // Incoming return from call to 0x1EF2 at 0x1EE5 // Inputs[3] // { // @1EE9 stack[-3] // @1EEB stack[-1] // @1EED stack[-4] // } 1EE6 5B JUMPDEST 1EE7 60 PUSH1 0x20 1EE9 83 DUP4 1EEA 01 ADD 1EEB 90 SWAP1 1EEC 50 POP 1EED 92 SWAP3 1EEE 91 SWAP2 1EEF 50 POP 1EF0 50 POP 1EF1 56 *JUMP // Stack delta = -3 // Outputs[1] { @1EED stack[-4] = stack[-3] + 0x20 } // Block ends with unconditional jump to stack[-4] label_1EF2: // Incoming call from 0x1EE5, returns to 0x1EE6 // Inputs[1] { @1EF6 stack[-1] } 1EF2 5B JUMPDEST 1EF3 61 PUSH2 0x1efb 1EF6 81 DUP2 1EF7 61 PUSH2 0x247b 1EFA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1EF3 stack[0] = 0x1efb // @1EF6 stack[1] = stack[-1] // } // Block ends with call to 0x247b, returns to 0x1EFB label_1EFB: // Incoming return from call to 0x247B at 0x1EFA // Inputs[3] // { // @1EFC stack[-3] // @1EFD stack[-1] // @1F00 stack[-4] // } 1EFB 5B JUMPDEST 1EFC 82 DUP3 1EFD 52 MSTORE 1EFE 50 POP 1EFF 50 POP 1F00 56 *JUMP // Stack delta = -4 // Outputs[1] { @1EFD memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1F01: // Incoming call from 0x213C, returns to 0x213D // Incoming call from 0x20ED, returns to 0x20EE // Incoming call from 0x2108, returns to 0x2109 // Incoming call from 0x22AA, returns to 0x22AB // Inputs[1] { @1F05 stack[-1] } 1F01 5B JUMPDEST 1F02 61 PUSH2 0x1f0a 1F05 81 DUP2 1F06 61 PUSH2 0x247b 1F09 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F02 stack[0] = 0x1f0a // @1F05 stack[1] = stack[-1] // } // Block ends with call to 0x247b, returns to 0x1F0A label_1F0A: // Incoming return from call to 0x247B at 0x1F09 // Inputs[3] // { // @1F0B stack[-3] // @1F0C stack[-1] // @1F0F stack[-4] // } 1F0A 5B JUMPDEST 1F0B 82 DUP3 1F0C 52 MSTORE 1F0D 50 POP 1F0E 50 POP 1F0F 56 *JUMP // Stack delta = -4 // Outputs[1] { @1F0C memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1F10: // Incoming call from 0x229B, returns to 0x229C // Inputs[1] { @1F16 stack[-1] } 1F10 5B JUMPDEST 1F11 60 PUSH1 0x00 1F13 61 PUSH2 0x1f1b 1F16 82 DUP3 1F17 61 PUSH2 0x2316 1F1A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F11 stack[0] = 0x00 // @1F13 stack[1] = 0x1f1b // @1F16 stack[2] = stack[-1] // } // Block ends with call to 0x2316, returns to 0x1F1B label_1F1B: // Incoming return from call to 0x2316 at 0x1F1A // Inputs[2] // { // @1F1F stack[-1] // @1F20 stack[-4] // } 1F1B 5B JUMPDEST 1F1C 61 PUSH2 0x1f25 1F1F 81 DUP2 1F20 85 DUP6 1F21 61 PUSH2 0x2339 1F24 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F1C stack[0] = 0x1f25 // @1F1F stack[1] = stack[-1] // @1F20 stack[2] = stack[-4] // } // Block ends with call to 0x2339, returns to 0x1F25 label_1F25: // Incoming return from call to 0x2339 at 0x1F24 // Inputs[3] // { // @1F26 stack[-1] // @1F26 stack[-5] // @1F2B stack[-4] // } 1F25 5B JUMPDEST 1F26 93 SWAP4 1F27 50 POP 1F28 61 PUSH2 0x1f30 1F2B 83 DUP4 1F2C 61 PUSH2 0x2306 1F2F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1F26 stack[-5] = stack[-1] // @1F28 stack[-1] = 0x1f30 // @1F2B stack[0] = stack[-4] // } // Block ends with call to 0x2306, returns to 0x1F30 label_1F30: // Incoming return from call to 0x2306 at 0x1F2F // Inputs[2] // { // @1F31 stack[-1] // @1F35 stack[-2] // } 1F30 5B JUMPDEST 1F31 80 DUP1 1F32 60 PUSH1 0x00 1F34 5B JUMPDEST 1F35 83 DUP4 1F36 81 DUP2 1F37 10 LT 1F38 15 ISZERO 1F39 61 PUSH2 0x1f61 1F3C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F31 stack[0] = stack[-1] // @1F32 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1f61, if !(0x00 < stack[-2]) label_1F3D: // Incoming jump from 0x1F3C, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1F3C, if not !(0x00 < stack[-2]) // Inputs[3] // { // @1F3D stack[-2] // @1F3E memory[stack[-2]:stack[-2] + 0x20] // @1F42 stack[-7] // } 1F3D 81 DUP2 1F3E 51 MLOAD 1F3F 61 PUSH2 0x1f48 1F42 88 DUP9 1F43 82 DUP3 1F44 61 PUSH2 0x1eda 1F47 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F3E stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1F3F stack[1] = 0x1f48 // @1F42 stack[2] = stack[-7] // @1F43 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1eda, returns to 0x1F48 label_1F48: // Incoming return from call to 0x1EDA at 0x1F47 // Inputs[3] // { // @1F49 stack[-9] // @1F49 stack[-1] // @1F4E stack[-4] // } 1F48 5B JUMPDEST 1F49 97 SWAP8 1F4A 50 POP 1F4B 61 PUSH2 0x1f53 1F4E 83 DUP4 1F4F 61 PUSH2 0x232c 1F52 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1F49 stack[-9] = stack[-1] // @1F4B stack[-1] = 0x1f53 // @1F4E stack[0] = stack[-4] // } // Block ends with call to 0x232c, returns to 0x1F53 label_1F53: // Incoming return from call to 0x232C at 0x1F52 // Inputs[3] // { // @1F54 stack[-4] // @1F54 stack[-1] // @1F59 stack[-3] // } 1F53 5B JUMPDEST 1F54 92 SWAP3 1F55 50 POP 1F56 50 POP 1F57 60 PUSH1 0x01 1F59 81 DUP2 1F5A 01 ADD 1F5B 90 SWAP1 1F5C 50 POP 1F5D 61 PUSH2 0x1f34 1F60 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1F54 stack[-4] = stack[-1] // @1F5B stack[-3] = stack[-3] + 0x01 // } // Block ends with unconditional jump to 0x1f34 label_1F61: // Incoming jump from 0x1F3C, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1F3C, if !(0x00 < stack[-2]) // Inputs[3] // { // @1F63 stack[-7] // @1F64 stack[-5] // @1F69 stack[-8] // } 1F61 5B JUMPDEST 1F62 50 POP 1F63 85 DUP6 1F64 93 SWAP4 1F65 50 POP 1F66 50 POP 1F67 50 POP 1F68 50 POP 1F69 92 SWAP3 1F6A 91 SWAP2 1F6B 50 POP 1F6C 50 POP 1F6D 56 *JUMP // Stack delta = -7 // Outputs[1] { @1F69 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_1F6E: // Incoming call from 0x2169, returns to 0x216A // Inputs[1] { @1F72 stack[-1] } 1F6E 5B JUMPDEST 1F6F 61 PUSH2 0x1f77 1F72 81 DUP2 1F73 61 PUSH2 0x248d 1F76 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F6F stack[0] = 0x1f77 // @1F72 stack[1] = stack[-1] // } // Block ends with call to 0x248d, returns to 0x1F77 label_1F77: // Incoming return from call to 0x248D at 0x1F76 // Inputs[3] // { // @1F78 stack[-3] // @1F79 stack[-1] // @1F7C stack[-4] // } 1F77 5B JUMPDEST 1F78 82 DUP3 1F79 52 MSTORE 1F7A 50 POP 1F7B 50 POP 1F7C 56 *JUMP // Stack delta = -4 // Outputs[1] { @1F79 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1F7D: // Incoming call from 0x2184, returns to 0x2185 // Inputs[1] { @1F81 stack[-1] } 1F7D 5B JUMPDEST 1F7E 61 PUSH2 0x1f86 1F81 81 DUP2 1F82 61 PUSH2 0x24d0 1F85 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F7E stack[0] = 0x1f86 // @1F81 stack[1] = stack[-1] // } // Block ends with call to 0x24d0, returns to 0x1F86 label_1F86: // Incoming return from call to 0x24D0 at 0x1F85 // Inputs[3] // { // @1F87 stack[-3] // @1F88 stack[-1] // @1F8B stack[-4] // } 1F86 5B JUMPDEST 1F87 82 DUP3 1F88 52 MSTORE 1F89 50 POP 1F8A 50 POP 1F8B 56 *JUMP // Stack delta = -4 // Outputs[1] { @1F88 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1F8C: // Incoming call from 0x2289, returns to 0x228A // Incoming call from 0x212F, returns to 0x2130 // Incoming call from 0x2122, returns to 0x2123 // Inputs[1] { @1F90 stack[-1] } 1F8C 5B JUMPDEST 1F8D 61 PUSH2 0x1f95 1F90 81 DUP2 1F91 61 PUSH2 0x24f4 1F94 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F8D stack[0] = 0x1f95 // @1F90 stack[1] = stack[-1] // } // Block ends with call to 0x24f4, returns to 0x1F95 label_1F95: // Incoming return from call to 0x24F4 at 0x1F94 // Inputs[3] // { // @1F96 stack[-3] // @1F97 stack[-1] // @1F9A stack[-4] // } 1F95 5B JUMPDEST 1F96 82 DUP3 1F97 52 MSTORE 1F98 50 POP 1F99 50 POP 1F9A 56 *JUMP // Stack delta = -4 // Outputs[1] { @1F97 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1F9B: // Incoming call from 0x21A4, returns to 0x21A5 // Inputs[1] { @1FA1 stack[-1] } 1F9B 5B JUMPDEST 1F9C 60 PUSH1 0x00 1F9E 61 PUSH2 0x1fa6 1FA1 82 DUP3 1FA2 61 PUSH2 0x2321 1FA5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F9C stack[0] = 0x00 // @1F9E stack[1] = 0x1fa6 // @1FA1 stack[2] = stack[-1] // } // Block ends with call to 0x2321, returns to 0x1FA6 label_1FA6: // Incoming return from call to 0x2321 at 0x1FA5 // Inputs[2] // { // @1FAA stack[-1] // @1FAB stack[-4] // } 1FA6 5B JUMPDEST 1FA7 61 PUSH2 0x1fb0 1FAA 81 DUP2 1FAB 85 DUP6 1FAC 61 PUSH2 0x2355 1FAF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FA7 stack[0] = 0x1fb0 // @1FAA stack[1] = stack[-1] // @1FAB stack[2] = stack[-4] // } // Block ends with call to 0x2355, returns to 0x1FB0 label_1FB0: // Incoming return from call to 0x2355 at 0x1FAF // Inputs[4] // { // @1FB1 stack[-5] // @1FB1 stack[-1] // @1FB6 stack[-2] // @1FBA stack[-4] // } 1FB0 5B JUMPDEST 1FB1 93 SWAP4 1FB2 50 POP 1FB3 61 PUSH2 0x1fc0 1FB6 81 DUP2 1FB7 85 DUP6 1FB8 60 PUSH1 0x20 1FBA 86 DUP7 1FBB 01 ADD 1FBC 61 PUSH2 0x2506 1FBF 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1FB1 stack[-5] = stack[-1] // @1FB3 stack[-1] = 0x1fc0 // @1FB6 stack[0] = stack[-2] // @1FB7 stack[1] = stack[-1] // @1FBB stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x2506, returns to 0x1FC0 label_1FC0: // Incoming return from call to 0x2506 at 0x1FBF // Inputs[1] { @1FC4 stack[-1] } 1FC0 5B JUMPDEST 1FC1 61 PUSH2 0x1fc9 1FC4 81 DUP2 1FC5 61 PUSH2 0x25fa 1FC8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1FC1 stack[0] = 0x1fc9 // @1FC4 stack[1] = stack[-1] // } // Block ends with call to 0x25fa, returns to 0x1FC9 label_1FC9: // Incoming return from call to 0x25FA at 0x1FC8 // Inputs[4] // { // @1FCA stack[-5] // @1FCB stack[-1] // @1FCC stack[-3] // @1FCF stack[-6] // } 1FC9 5B JUMPDEST 1FCA 84 DUP5 1FCB 01 ADD 1FCC 91 SWAP2 1FCD 50 POP 1FCE 50 POP 1FCF 92 SWAP3 1FD0 91 SWAP2 1FD1 50 POP 1FD2 50 POP 1FD3 56 *JUMP // Stack delta = -5 // Outputs[1] { @1FCF stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_1FD4: // Incoming call from 0x21C5, returns to 0x21C6 // Inputs[1] { @1FDC stack[-1] } 1FD4 5B JUMPDEST 1FD5 60 PUSH1 0x00 1FD7 61 PUSH2 0x1fe1 1FDA 60 PUSH1 0x25 1FDC 83 DUP4 1FDD 61 PUSH2 0x2355 1FE0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FD5 stack[0] = 0x00 // @1FD7 stack[1] = 0x1fe1 // @1FDA stack[2] = 0x25 // @1FDC stack[3] = stack[-1] // } // Block ends with call to 0x2355, returns to 0x1FE1 label_1FE1: // Incoming return from call to 0x2355 at 0x1FE0 // Inputs[2] // { // @1FE2 stack[-3] // @1FE2 stack[-1] // } 1FE1 5B JUMPDEST 1FE2 91 SWAP2 1FE3 50 POP 1FE4 61 PUSH2 0x1fec 1FE7 82 DUP3 1FE8 61 PUSH2 0x260b 1FEB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1FE2 stack[-3] = stack[-1] // @1FE4 stack[-1] = 0x1fec // @1FE7 stack[0] = stack[-1] // } // Block ends with call to 0x260b, returns to 0x1FEC label_1FEC: // Incoming return from call to 0x260B at 0x1FEB // Inputs[3] // { // @1FEF stack[-2] // @1FF1 stack[-1] // @1FF3 stack[-3] // } 1FEC 5B JUMPDEST 1FED 60 PUSH1 0x40 1FEF 82 DUP3 1FF0 01 ADD 1FF1 90 SWAP1 1FF2 50 POP 1FF3 91 SWAP2 1FF4 90 SWAP1 1FF5 50 POP 1FF6 56 *JUMP // Stack delta = -2 // Outputs[1] { @1FF3 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1FF7: // Incoming call from 0x21E5, returns to 0x21E6 // Inputs[1] { @1FFF stack[-1] } 1FF7 5B JUMPDEST 1FF8 60 PUSH1 0x00 1FFA 61 PUSH2 0x2004 1FFD 60 PUSH1 0x1b 1FFF 83 DUP4 2000 61 PUSH2 0x2355 2003 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FF8 stack[0] = 0x00 // @1FFA stack[1] = 0x2004 // @1FFD stack[2] = 0x1b // @1FFF stack[3] = stack[-1] // } // Block ends with call to 0x2355, returns to 0x2004 label_2004: // Incoming return from call to 0x2355 at 0x2003 // Inputs[2] // { // @2005 stack[-1] // @2005 stack[-3] // } 2004 5B JUMPDEST 2005 91 SWAP2 2006 50 POP 2007 61 PUSH2 0x200f 200A 82 DUP3 200B 61 PUSH2 0x265a 200E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2005 stack[-3] = stack[-1] // @2007 stack[-1] = 0x200f // @200A stack[0] = stack[-1] // } // Block ends with call to 0x265a, returns to 0x200F label_200F: // Incoming return from call to 0x265A at 0x200E // Inputs[3] // { // @2012 stack[-2] // @2014 stack[-1] // @2016 stack[-3] // } 200F 5B JUMPDEST 2010 60 PUSH1 0x20 2012 82 DUP3 2013 01 ADD 2014 90 SWAP1 2015 50 POP 2016 91 SWAP2 2017 90 SWAP1 2018 50 POP 2019 56 *JUMP // Stack delta = -2 // Outputs[1] { @2016 stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_201A: // Incoming call from 0x2205, returns to 0x2206 // Inputs[1] { @2022 stack[-1] } 201A 5B JUMPDEST 201B 60 PUSH1 0x00 201D 61 PUSH2 0x2027 2020 60 PUSH1 0x1e 2022 83 DUP4 2023 61 PUSH2 0x2355 2026 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @201B stack[0] = 0x00 // @201D stack[1] = 0x2027 // @2020 stack[2] = 0x1e // @2022 stack[3] = stack[-1] // } // Block ends with call to 0x2355, returns to 0x2027 label_2027: // Incoming return from call to 0x2355 at 0x2026 // Inputs[2] // { // @2028 stack[-3] // @2028 stack[-1] // } 2027 5B JUMPDEST 2028 91 SWAP2 2029 50 POP 202A 61 PUSH2 0x2032 202D 82 DUP3 202E 61 PUSH2 0x2683 2031 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2028 stack[-3] = stack[-1] // @202A stack[-1] = 0x2032 // @202D stack[0] = stack[-1] // } // Block ends with call to 0x2683, returns to 0x2032 label_2032: // Incoming return from call to 0x2683 at 0x2031 // Inputs[3] // { // @2035 stack[-2] // @2037 stack[-1] // @2039 stack[-3] // } 2032 5B JUMPDEST 2033 60 PUSH1 0x20 2035 82 DUP3 2036 01 ADD 2037 90 SWAP1 2038 50 POP 2039 91 SWAP2 203A 90 SWAP1 203B 50 POP 203C 56 *JUMP // Stack delta = -2 // Outputs[1] { @2039 stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_203D: // Incoming call from 0x2225, returns to 0x2226 // Inputs[1] { @2045 stack[-1] } 203D 5B JUMPDEST 203E 60 PUSH1 0x00 2040 61 PUSH2 0x204a 2043 60 PUSH1 0x21 2045 83 DUP4 2046 61 PUSH2 0x2355 2049 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @203E stack[0] = 0x00 // @2040 stack[1] = 0x204a // @2043 stack[2] = 0x21 // @2045 stack[3] = stack[-1] // } // Block ends with call to 0x2355, returns to 0x204A label_204A: // Incoming return from call to 0x2355 at 0x2049 // Inputs[2] // { // @204B stack[-3] // @204B stack[-1] // } 204A 5B JUMPDEST 204B 91 SWAP2 204C 50 POP 204D 61 PUSH2 0x2055 2050 82 DUP3 2051 61 PUSH2 0x26ac 2054 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @204B stack[-3] = stack[-1] // @204D stack[-1] = 0x2055 // @2050 stack[0] = stack[-1] // } // Block ends with call to 0x26ac, returns to 0x2055 label_2055: // Incoming return from call to 0x26AC at 0x2054 // Inputs[3] // { // @2058 stack[-2] // @205A stack[-1] // @205C stack[-3] // } 2055 5B JUMPDEST 2056 60 PUSH1 0x40 2058 82 DUP3 2059 01 ADD 205A 90 SWAP1 205B 50 POP 205C 91 SWAP2 205D 90 SWAP1 205E 50 POP 205F 56 *JUMP // Stack delta = -2 // Outputs[1] { @205C stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_2060: // Incoming call from 0x2245, returns to 0x2246 // Inputs[1] { @2068 stack[-1] } 2060 5B JUMPDEST 2061 60 PUSH1 0x00 2063 61 PUSH2 0x206d 2066 60 PUSH1 0x06 2068 83 DUP4 2069 61 PUSH2 0x2355 206C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2061 stack[0] = 0x00 // @2063 stack[1] = 0x206d // @2066 stack[2] = 0x06 // @2068 stack[3] = stack[-1] // } // Block ends with call to 0x2355, returns to 0x206D label_206D: // Incoming return from call to 0x2355 at 0x206C // Inputs[2] // { // @206E stack[-1] // @206E stack[-3] // } 206D 5B JUMPDEST 206E 91 SWAP2 206F 50 POP 2070 61 PUSH2 0x2078 2073 82 DUP3 2074 61 PUSH2 0x26fb 2077 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @206E stack[-3] = stack[-1] // @2070 stack[-1] = 0x2078 // @2073 stack[0] = stack[-1] // } // Block ends with call to 0x26fb, returns to 0x2078 label_2078: // Incoming return from call to 0x26FB at 0x2077 // Inputs[3] // { // @207B stack[-2] // @207D stack[-1] // @207F stack[-3] // } 2078 5B JUMPDEST 2079 60 PUSH1 0x20 207B 82 DUP3 207C 01 ADD 207D 90 SWAP1 207E 50 POP 207F 91 SWAP2 2080 90 SWAP1 2081 50 POP 2082 56 *JUMP // Stack delta = -2 // Outputs[1] { @207F stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_2083: // Incoming call from 0x20CE, returns to 0x20CF // Inputs[1] { @208B stack[-1] } 2083 5B JUMPDEST 2084 60 PUSH1 0x00 2086 61 PUSH2 0x2090 2089 60 PUSH1 0x00 208B 83 DUP4 208C 61 PUSH2 0x234a 208F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2084 stack[0] = 0x00 // @2086 stack[1] = 0x2090 // @2089 stack[2] = 0x00 // @208B stack[3] = stack[-1] // } // Block ends with call to 0x234a, returns to 0x2090 label_2090: // Incoming return from call to 0x234A at 0x208F // Inputs[2] // { // @2091 stack[-1] // @2091 stack[-3] // } 2090 5B JUMPDEST 2091 91 SWAP2 2092 50 POP 2093 61 PUSH2 0x209b 2096 82 DUP3 2097 61 PUSH2 0x2724 209A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2091 stack[-3] = stack[-1] // @2093 stack[-1] = 0x209b // @2096 stack[0] = stack[-1] // } // Block ends with call to 0x2724, returns to 0x209B label_209B: // Incoming return from call to 0x2724 at 0x209A // Inputs[3] // { // @209E stack[-2] // @20A0 stack[-1] // @20A2 stack[-3] // } 209B 5B JUMPDEST 209C 60 PUSH1 0x00 209E 82 DUP3 209F 01 ADD 20A0 90 SWAP1 20A1 50 POP 20A2 91 SWAP2 20A3 90 SWAP1 20A4 50 POP 20A5 56 *JUMP // Stack delta = -2 // Outputs[1] { @20A2 stack[-3] = stack[-2] + 0x00 } // Block ends with unconditional jump to stack[-3] label_20A6: // Incoming call from 0x227C, returns to 0x227D // Incoming call from 0x2115, returns to 0x2116 // Incoming call from 0x22E3, returns to 0x22E4 // Incoming call from 0x22D6, returns to 0x22D7 // Incoming call from 0x2149, returns to 0x214A // Incoming call from 0x2261, returns to 0x2262 // Incoming call from 0x22B7, returns to 0x22B8 // Inputs[1] { @20AA stack[-1] } 20A6 5B JUMPDEST 20A7 61 PUSH2 0x20af 20AA 81 DUP2 20AB 61 PUSH2 0x24b9 20AE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @20A7 stack[0] = 0x20af // @20AA stack[1] = stack[-1] // } // Block ends with call to 0x24b9, returns to 0x20AF label_20AF: // Incoming return from call to 0x24B9 at 0x20AE // Inputs[3] // { // @20B0 stack[-3] // @20B1 stack[-1] // @20B4 stack[-4] // } 20AF 5B JUMPDEST 20B0 82 DUP3 20B1 52 MSTORE 20B2 50 POP 20B3 50 POP 20B4 56 *JUMP // Stack delta = -4 // Outputs[1] { @20B1 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_20B5: // Incoming call from 0x22FF, returns to 0x2300 // Inputs[1] { @20B9 stack[-1] } 20B5 5B JUMPDEST 20B6 61 PUSH2 0x20be 20B9 81 DUP2 20BA 61 PUSH2 0x24c3 20BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @20B6 stack[0] = 0x20be // @20B9 stack[1] = stack[-1] // } // Block ends with call to 0x24c3, returns to 0x20BE label_20BE: // Incoming return from call to 0x24C3 at 0x20BD // Inputs[3] // { // @20BF stack[-3] // @20C0 stack[-1] // @20C3 stack[-4] // } 20BE 5B JUMPDEST 20BF 82 DUP3 20C0 52 MSTORE 20C1 50 POP 20C2 50 POP 20C3 56 *JUMP // Stack delta = -4 // Outputs[1] { @20C0 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_20C4: // Incoming call from 0x176C, returns to 0x176D // Inputs[1] { @20CA stack[-1] } 20C4 5B JUMPDEST 20C5 60 PUSH1 0x00 20C7 61 PUSH2 0x20cf 20CA 82 DUP3 20CB 61 PUSH2 0x2083 20CE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20C5 stack[0] = 0x00 // @20C7 stack[1] = 0x20cf // @20CA stack[2] = stack[-1] // } // Block ends with call to 0x2083, returns to 0x20CF label_20CF: // Incoming return from call to 0x2083 at 0x20CE // Inputs[4] // { // @20D0 stack[-3] // @20D0 stack[-1] // @20D3 stack[-2] // @20D5 stack[-4] // } 20CF 5B JUMPDEST 20D0 91 SWAP2 20D1 50 POP 20D2 81 DUP2 20D3 90 SWAP1 20D4 50 POP 20D5 91 SWAP2 20D6 90 SWAP1 20D7 50 POP 20D8 56 *JUMP // Stack delta = -3 // Outputs[1] { @20D5 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_20D9: // Incoming call from 0x03F0, returns to 0x03F1 // Incoming call from 0x04EB, returns to 0x04EC // Incoming call from 0x0B12, returns to 0x0B13 // Incoming call from 0x0446, returns to 0x0447 // Inputs[2] // { // @20DE stack[-1] // @20E9 stack[-2] // } 20D9 5B JUMPDEST 20DA 60 PUSH1 0x00 20DC 60 PUSH1 0x20 20DE 82 DUP3 20DF 01 ADD 20E0 90 SWAP1 20E1 50 POP 20E2 61 PUSH2 0x20ee 20E5 60 PUSH1 0x00 20E7 83 DUP4 20E8 01 ADD 20E9 84 DUP5 20EA 61 PUSH2 0x1f01 20ED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20E0 stack[0] = stack[-1] + 0x20 // @20E2 stack[1] = 0x20ee // @20E8 stack[2] = stack[-1] + 0x00 // @20E9 stack[3] = stack[-2] // } // Block ends with call to 0x1f01, returns to 0x20EE label_20EE: // Incoming return from call to 0x1F01 at 0x20ED // Inputs[3] // { // @20EF stack[-1] // @20EF stack[-4] // @20F0 stack[-3] // } 20EE 5B JUMPDEST 20EF 92 SWAP3 20F0 91 SWAP2 20F1 50 POP 20F2 50 POP 20F3 56 *JUMP // Stack delta = -3 // Outputs[1] { @20EF stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_20F4: // Incoming call from 0x1877, returns to 0x1878 // Inputs[2] // { // @20F9 stack[-1] // @2104 stack[-7] // } 20F4 5B JUMPDEST 20F5 60 PUSH1 0x00 20F7 60 PUSH1 0xc0 20F9 82 DUP3 20FA 01 ADD 20FB 90 SWAP1 20FC 50 POP 20FD 61 PUSH2 0x2109 2100 60 PUSH1 0x00 2102 83 DUP4 2103 01 ADD 2104 89 DUP10 2105 61 PUSH2 0x1f01 2108 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20FB stack[0] = stack[-1] + 0xc0 // @20FD stack[1] = 0x2109 // @2103 stack[2] = stack[-1] + 0x00 // @2104 stack[3] = stack[-7] // } // Block ends with call to 0x1f01, returns to 0x2109 label_2109: // Incoming return from call to 0x1F01 at 0x2108 // Inputs[2] // { // @210F stack[-2] // @2111 stack[-7] // } 2109 5B JUMPDEST 210A 61 PUSH2 0x2116 210D 60 PUSH1 0x20 210F 83 DUP4 2110 01 ADD 2111 88 DUP9 2112 61 PUSH2 0x20a6 2115 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @210A stack[0] = 0x2116 // @2110 stack[1] = stack[-2] + 0x20 // @2111 stack[2] = stack[-7] // } // Block ends with call to 0x20a6, returns to 0x2116 label_2116: // Incoming return from call to 0x20A6 at 0x2115 // Inputs[2] // { // @211C stack[-2] // @211E stack[-6] // } 2116 5B JUMPDEST 2117 61 PUSH2 0x2123 211A 60 PUSH1 0x40 211C 83 DUP4 211D 01 ADD 211E 87 DUP8 211F 61 PUSH2 0x1f8c 2122 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2117 stack[0] = 0x2123 // @211D stack[1] = stack[-2] + 0x40 // @211E stack[2] = stack[-6] // } // Block ends with call to 0x1f8c, returns to 0x2123 label_2123: // Incoming return from call to 0x1F8C at 0x2122 // Inputs[2] // { // @2129 stack[-2] // @212B stack[-5] // } 2123 5B JUMPDEST 2124 61 PUSH2 0x2130 2127 60 PUSH1 0x60 2129 83 DUP4 212A 01 ADD 212B 86 DUP7 212C 61 PUSH2 0x1f8c 212F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2124 stack[0] = 0x2130 // @212A stack[1] = stack[-2] + 0x60 // @212B stack[2] = stack[-5] // } // Block ends with call to 0x1f8c, returns to 0x2130 label_2130: // Incoming return from call to 0x1F8C at 0x212F // Inputs[2] // { // @2136 stack[-2] // @2138 stack[-4] // } 2130 5B JUMPDEST 2131 61 PUSH2 0x213d 2134 60 PUSH1 0x80 2136 83 DUP4 2137 01 ADD 2138 85 DUP6 2139 61 PUSH2 0x1f01 213C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2131 stack[0] = 0x213d // @2137 stack[1] = stack[-2] + 0x80 // @2138 stack[2] = stack[-4] // } // Block ends with call to 0x1f01, returns to 0x213D label_213D: // Incoming return from call to 0x1F01 at 0x213C // Inputs[2] // { // @2143 stack[-2] // @2145 stack[-3] // } 213D 5B JUMPDEST 213E 61 PUSH2 0x214a 2141 60 PUSH1 0xa0 2143 83 DUP4 2144 01 ADD 2145 84 DUP5 2146 61 PUSH2 0x20a6 2149 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @213E stack[0] = 0x214a // @2144 stack[1] = stack[-2] + 0xa0 // @2145 stack[2] = stack[-3] // } // Block ends with call to 0x20a6, returns to 0x214A label_214A: // Incoming return from call to 0x20A6 at 0x2149 // Inputs[3] // { // @214B stack[-1] // @214B stack[-9] // @214C stack[-8] // } 214A 5B JUMPDEST 214B 97 SWAP8 214C 96 SWAP7 214D 50 POP 214E 50 POP 214F 50 POP 2150 50 POP 2151 50 POP 2152 50 POP 2153 50 POP 2154 56 *JUMP // Stack delta = -8 // Outputs[1] { @214B stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_2155: // Incoming call from 0x01CE, returns to 0x01CF // Incoming call from 0x0236, returns to 0x0237 // Incoming call from 0x031B, returns to 0x031C // Incoming call from 0x0273, returns to 0x0274 // Incoming call from 0x0371, returns to 0x0372 // Incoming call from 0x0483, returns to 0x0484 // Inputs[2] // { // @215A stack[-1] // @2165 stack[-2] // } 2155 5B JUMPDEST 2156 60 PUSH1 0x00 2158 60 PUSH1 0x20 215A 82 DUP3 215B 01 ADD 215C 90 SWAP1 215D 50 POP 215E 61 PUSH2 0x216a 2161 60 PUSH1 0x00 2163 83 DUP4 2164 01 ADD 2165 84 DUP5 2166 61 PUSH2 0x1f6e 2169 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @215C stack[0] = stack[-1] + 0x20 // @215E stack[1] = 0x216a // @2164 stack[2] = stack[-1] + 0x00 // @2165 stack[3] = stack[-2] // } // Block ends with call to 0x1f6e, returns to 0x216A label_216A: // Incoming return from call to 0x1F6E at 0x2169 // Inputs[3] // { // @216B stack[-4] // @216B stack[-1] // @216C stack[-3] // } 216A 5B JUMPDEST 216B 92 SWAP3 216C 91 SWAP2 216D 50 POP 216E 50 POP 216F 56 *JUMP // Stack delta = -3 // Outputs[1] { @216B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2170: // Incoming call from 0x053F, returns to 0x0540 // Inputs[2] // { // @2175 stack[-1] // @2180 stack[-2] // } 2170 5B JUMPDEST 2171 60 PUSH1 0x00 2173 60 PUSH1 0x20 2175 82 DUP3 2176 01 ADD 2177 90 SWAP1 2178 50 POP 2179 61 PUSH2 0x2185 217C 60 PUSH1 0x00 217E 83 DUP4 217F 01 ADD 2180 84 DUP5 2181 61 PUSH2 0x1f7d 2184 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2177 stack[0] = stack[-1] + 0x20 // @2179 stack[1] = 0x2185 // @217F stack[2] = stack[-1] + 0x00 // @2180 stack[3] = stack[-2] // } // Block ends with call to 0x1f7d, returns to 0x2185 label_2185: // Incoming return from call to 0x1F7D at 0x2184 // Inputs[3] // { // @2186 stack[-1] // @2186 stack[-4] // @2187 stack[-3] // } 2185 5B JUMPDEST 2186 92 SWAP3 2187 91 SWAP2 2188 50 POP 2189 50 POP 218A 56 *JUMP // Stack delta = -3 // Outputs[1] { @2186 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_218B: // Incoming call from 0x0D3B, returns to 0x0D3C // Incoming call from 0x1C73, returns to 0x1C74 // Incoming call from 0x0191, returns to 0x0192 // Incoming call from 0x041B, returns to 0x041C // Inputs[2] // { // @2190 stack[-1] // @21A0 stack[-2] // } 218B 5B JUMPDEST 218C 60 PUSH1 0x00 218E 60 PUSH1 0x20 2190 82 DUP3 2191 01 ADD 2192 90 SWAP1 2193 50 POP 2194 81 DUP2 2195 81 DUP2 2196 03 SUB 2197 60 PUSH1 0x00 2199 83 DUP4 219A 01 ADD 219B 52 MSTORE 219C 61 PUSH2 0x21a5 219F 81 DUP2 21A0 84 DUP5 21A1 61 PUSH2 0x1f9b 21A4 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2192 stack[0] = stack[-1] + 0x20 // @219B memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @219C stack[1] = 0x21a5 // @219F stack[2] = stack[-1] + 0x20 // @21A0 stack[3] = stack[-2] // } // Block ends with call to 0x1f9b, returns to 0x21A5 label_21A5: // Incoming return from call to 0x1F9B at 0x21A4 // Inputs[4] // { // @21A6 stack[-2] // @21A6 stack[-1] // @21A8 stack[-5] // @21A9 stack[-4] // } 21A5 5B JUMPDEST 21A6 90 SWAP1 21A7 50 POP 21A8 92 SWAP3 21A9 91 SWAP2 21AA 50 POP 21AB 50 POP 21AC 56 *JUMP // Stack delta = -4 // Outputs[1] { @21A8 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_21AD: // Incoming call from 0x0F14, returns to 0x0F15 // Inputs[1] { @21B2 stack[-1] } 21AD 5B JUMPDEST 21AE 60 PUSH1 0x00 21B0 60 PUSH1 0x20 21B2 82 DUP3 21B3 01 ADD 21B4 90 SWAP1 21B5 50 POP 21B6 81 DUP2 21B7 81 DUP2 21B8 03 SUB 21B9 60 PUSH1 0x00 21BB 83 DUP4 21BC 01 ADD 21BD 52 MSTORE 21BE 61 PUSH2 0x21c6 21C1 81 DUP2 21C2 61 PUSH2 0x1fd4 21C5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @21B4 stack[0] = stack[-1] + 0x20 // @21BD memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @21BE stack[1] = 0x21c6 // @21C1 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1fd4, returns to 0x21C6 label_21C6: // Incoming return from call to 0x1FD4 at 0x21C5 // Inputs[4] // { // @21C7 stack[-2] // @21C7 stack[-1] // @21C9 stack[-4] // @21CA stack[-3] // } 21C6 5B JUMPDEST 21C7 90 SWAP1 21C8 50 POP 21C9 91 SWAP2 21CA 90 SWAP1 21CB 50 POP 21CC 56 *JUMP // Stack delta = -3 // Outputs[1] { @21C9 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_21CD: // Incoming call from 0x1B13, returns to 0x1B14 // Inputs[1] { @21D2 stack[-1] } 21CD 5B JUMPDEST 21CE 60 PUSH1 0x00 21D0 60 PUSH1 0x20 21D2 82 DUP3 21D3 01 ADD 21D4 90 SWAP1 21D5 50 POP 21D6 81 DUP2 21D7 81 DUP2 21D8 03 SUB 21D9 60 PUSH1 0x00 21DB 83 DUP4 21DC 01 ADD 21DD 52 MSTORE 21DE 61 PUSH2 0x21e6 21E1 81 DUP2 21E2 61 PUSH2 0x1ff7 21E5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @21D4 stack[0] = stack[-1] + 0x20 // @21DD memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @21DE stack[1] = 0x21e6 // @21E1 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1ff7, returns to 0x21E6 label_21E6: // Incoming return from call to 0x1FF7 at 0x21E5 // Inputs[4] // { // @21E7 stack[-1] // @21E7 stack[-2] // @21E9 stack[-4] // @21EA stack[-3] // } 21E6 5B JUMPDEST 21E7 90 SWAP1 21E8 50 POP 21E9 91 SWAP2 21EA 90 SWAP1 21EB 50 POP 21EC 56 *JUMP // Stack delta = -3 // Outputs[1] { @21E9 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_21ED: // Incoming call from 0x17EA, returns to 0x17EB // Inputs[1] { @21F2 stack[-1] } 21ED 5B JUMPDEST 21EE 60 PUSH1 0x00 21F0 60 PUSH1 0x20 21F2 82 DUP3 21F3 01 ADD 21F4 90 SWAP1 21F5 50 POP 21F6 81 DUP2 21F7 81 DUP2 21F8 03 SUB 21F9 60 PUSH1 0x00 21FB 83 DUP4 21FC 01 ADD 21FD 52 MSTORE 21FE 61 PUSH2 0x2206 2201 81 DUP2 2202 61 PUSH2 0x201a 2205 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @21F4 stack[0] = stack[-1] + 0x20 // @21FD memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @21FE stack[1] = 0x2206 // @2201 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x201a, returns to 0x2206 label_2206: // Incoming return from call to 0x201A at 0x2205 // Inputs[4] // { // @2207 stack[-2] // @2207 stack[-1] // @2209 stack[-4] // @220A stack[-3] // } 2206 5B JUMPDEST 2207 90 SWAP1 2208 50 POP 2209 91 SWAP2 220A 90 SWAP1 220B 50 POP 220C 56 *JUMP // Stack delta = -3 // Outputs[1] { @2209 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_220D: // Incoming call from 0x1B8D, returns to 0x1B8E // Inputs[1] { @2212 stack[-1] } 220D 5B JUMPDEST 220E 60 PUSH1 0x00 2210 60 PUSH1 0x20 2212 82 DUP3 2213 01 ADD 2214 90 SWAP1 2215 50 POP 2216 81 DUP2 2217 81 DUP2 2218 03 SUB 2219 60 PUSH1 0x00 221B 83 DUP4 221C 01 ADD 221D 52 MSTORE 221E 61 PUSH2 0x2226 2221 81 DUP2 2222 61 PUSH2 0x203d 2225 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2214 stack[0] = stack[-1] + 0x20 // @221D memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @221E stack[1] = 0x2226 // @2221 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x203d, returns to 0x2226 label_2226: // Incoming return from call to 0x203D at 0x2225 // Inputs[4] // { // @2227 stack[-1] // @2227 stack[-2] // @2229 stack[-4] // @222A stack[-3] // } 2226 5B JUMPDEST 2227 90 SWAP1 2228 50 POP 2229 91 SWAP2 222A 90 SWAP1 222B 50 POP 222C 56 *JUMP // Stack delta = -3 // Outputs[1] { @2229 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_222D: // Incoming call from 0x0A98, returns to 0x0A99 // Incoming call from 0x0993, returns to 0x0994 // Incoming call from 0x0CA9, returns to 0x0CAA // Inputs[1] { @2232 stack[-1] } 222D 5B JUMPDEST 222E 60 PUSH1 0x00 2230 60 PUSH1 0x20 2232 82 DUP3 2233 01 ADD 2234 90 SWAP1 2235 50 POP 2236 81 DUP2 2237 81 DUP2 2238 03 SUB 2239 60 PUSH1 0x00 223B 83 DUP4 223C 01 ADD 223D 52 MSTORE 223E 61 PUSH2 0x2246 2241 81 DUP2 2242 61 PUSH2 0x2060 2245 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2234 stack[0] = stack[-1] + 0x20 // @223D memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @223E stack[1] = 0x2246 // @2241 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2060, returns to 0x2246 label_2246: // Incoming return from call to 0x2060 at 0x2245 // Inputs[4] // { // @2247 stack[-2] // @2247 stack[-1] // @2249 stack[-4] // @224A stack[-3] // } 2246 5B JUMPDEST 2247 90 SWAP1 2248 50 POP 2249 91 SWAP2 224A 90 SWAP1 224B 50 POP 224C 56 *JUMP // Stack delta = -3 // Outputs[1] { @2249 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_224D: // Incoming call from 0x1114, returns to 0x1115 // Incoming call from 0x0166, returns to 0x0167 // Incoming call from 0x03AE, returns to 0x03AF // Incoming call from 0x1AA4, returns to 0x1AA5 // Incoming call from 0x0346, returns to 0x0347 // Incoming call from 0x04C0, returns to 0x04C1 // Incoming call from 0x066B, returns to 0x066C // Incoming call from 0x12E9, returns to 0x12EA // Incoming call from 0x01F9, returns to 0x01FA // Inputs[2] // { // @2252 stack[-1] // @225D stack[-2] // } 224D 5B JUMPDEST 224E 60 PUSH1 0x00 2250 60 PUSH1 0x20 2252 82 DUP3 2253 01 ADD 2254 90 SWAP1 2255 50 POP 2256 61 PUSH2 0x2262 2259 60 PUSH1 0x00 225B 83 DUP4 225C 01 ADD 225D 84 DUP5 225E 61 PUSH2 0x20a6 2261 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2254 stack[0] = stack[-1] + 0x20 // @2256 stack[1] = 0x2262 // @225C stack[2] = stack[-1] + 0x00 // @225D stack[3] = stack[-2] // } // Block ends with call to 0x20a6, returns to 0x2262 label_2262: // Incoming return from call to 0x20A6 at 0x2261 // Inputs[3] // { // @2263 stack[-1] // @2263 stack[-4] // @2264 stack[-3] // } 2262 5B JUMPDEST 2263 92 SWAP3 2264 91 SWAP2 2265 50 POP 2266 50 POP 2267 56 *JUMP // Stack delta = -3 // Outputs[1] { @2263 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2268: // Incoming call from 0x1640, returns to 0x1641 // Inputs[2] // { // @226D stack[-1] // @2278 stack[-6] // } 2268 5B JUMPDEST 2269 60 PUSH1 0x00 226B 60 PUSH1 0xa0 226D 82 DUP3 226E 01 ADD 226F 90 SWAP1 2270 50 POP 2271 61 PUSH2 0x227d 2274 60 PUSH1 0x00 2276 83 DUP4 2277 01 ADD 2278 88 DUP9 2279 61 PUSH2 0x20a6 227C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @226F stack[0] = stack[-1] + 0xa0 // @2271 stack[1] = 0x227d // @2277 stack[2] = stack[-1] + 0x00 // @2278 stack[3] = stack[-6] // } // Block ends with call to 0x20a6, returns to 0x227D label_227D: // Incoming return from call to 0x20A6 at 0x227C // Inputs[2] // { // @2283 stack[-2] // @2285 stack[-6] // } 227D 5B JUMPDEST 227E 61 PUSH2 0x228a 2281 60 PUSH1 0x20 2283 83 DUP4 2284 01 ADD 2285 87 DUP8 2286 61 PUSH2 0x1f8c 2289 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @227E stack[0] = 0x228a // @2284 stack[1] = stack[-2] + 0x20 // @2285 stack[2] = stack[-6] // } // Block ends with call to 0x1f8c, returns to 0x228A label_228A: // Incoming return from call to 0x1F8C at 0x2289 // Inputs[3] // { // @228B stack[-2] // @228C stack[-1] // @2297 stack[-5] // } 228A 5B JUMPDEST 228B 81 DUP2 228C 81 DUP2 228D 03 SUB 228E 60 PUSH1 0x40 2290 83 DUP4 2291 01 ADD 2292 52 MSTORE 2293 61 PUSH2 0x229c 2296 81 DUP2 2297 86 DUP7 2298 61 PUSH2 0x1f10 229B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2292 memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] = stack[-1] - stack[-2] // @2293 stack[0] = 0x229c // @2296 stack[1] = stack[-1] // @2297 stack[2] = stack[-5] // } // Block ends with call to 0x1f10, returns to 0x229C label_229C: // Incoming return from call to 0x1F10 at 0x229B // Inputs[4] // { // @229D stack[-2] // @229D stack[-1] // @22A4 stack[-3] // @22A6 stack[-5] // } 229C 5B JUMPDEST 229D 90 SWAP1 229E 50 POP 229F 61 PUSH2 0x22ab 22A2 60 PUSH1 0x60 22A4 83 DUP4 22A5 01 ADD 22A6 85 DUP6 22A7 61 PUSH2 0x1f01 22AA 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @229D stack[-2] = stack[-1] // @229F stack[-1] = 0x22ab // @22A5 stack[0] = stack[-3] + 0x60 // @22A6 stack[1] = stack[-5] // } // Block ends with call to 0x1f01, returns to 0x22AB label_22AB: // Incoming return from call to 0x1F01 at 0x22AA // Inputs[2] // { // @22B1 stack[-2] // @22B3 stack[-3] // } 22AB 5B JUMPDEST 22AC 61 PUSH2 0x22b8 22AF 60 PUSH1 0x80 22B1 83 DUP4 22B2 01 ADD 22B3 84 DUP5 22B4 61 PUSH2 0x20a6 22B7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22AC stack[0] = 0x22b8 // @22B2 stack[1] = stack[-2] + 0x80 // @22B3 stack[2] = stack[-3] // } // Block ends with call to 0x20a6, returns to 0x22B8 label_22B8: // Incoming return from call to 0x20A6 at 0x22B7 // Inputs[3] // { // @22B9 stack[-8] // @22B9 stack[-1] // @22BA stack[-7] // } 22B8 5B JUMPDEST 22B9 96 SWAP7 22BA 95 SWAP6 22BB 50 POP 22BC 50 POP 22BD 50 POP 22BE 50 POP 22BF 50 POP 22C0 50 POP 22C1 56 *JUMP // Stack delta = -7 // Outputs[1] { @22B9 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_22C2: // Incoming call from 0x18FD, returns to 0x18FE // Inputs[2] // { // @22C7 stack[-1] // @22D2 stack[-3] // } 22C2 5B JUMPDEST 22C3 60 PUSH1 0x00 22C5 60 PUSH1 0x40 22C7 82 DUP3 22C8 01 ADD 22C9 90 SWAP1 22CA 50 POP 22CB 61 PUSH2 0x22d7 22CE 60 PUSH1 0x00 22D0 83 DUP4 22D1 01 ADD 22D2 85 DUP6 22D3 61 PUSH2 0x20a6 22D6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22C9 stack[0] = stack[-1] + 0x40 // @22CB stack[1] = 0x22d7 // @22D1 stack[2] = stack[-1] + 0x00 // @22D2 stack[3] = stack[-3] // } // Block ends with call to 0x20a6, returns to 0x22D7 label_22D7: // Incoming return from call to 0x20A6 at 0x22D6 // Inputs[2] // { // @22DD stack[-2] // @22DF stack[-3] // } 22D7 5B JUMPDEST 22D8 61 PUSH2 0x22e4 22DB 60 PUSH1 0x20 22DD 83 DUP4 22DE 01 ADD 22DF 84 DUP5 22E0 61 PUSH2 0x20a6 22E3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22D8 stack[0] = 0x22e4 // @22DE stack[1] = stack[-2] + 0x20 // @22DF stack[2] = stack[-3] // } // Block ends with call to 0x20a6, returns to 0x22E4 label_22E4: // Incoming return from call to 0x20A6 at 0x22E3 // Inputs[3] // { // @22E5 stack[-5] // @22E5 stack[-1] // @22E6 stack[-4] // } 22E4 5B JUMPDEST 22E5 93 SWAP4 22E6 92 SWAP3 22E7 50 POP 22E8 50 POP 22E9 50 POP 22EA 56 *JUMP // Stack delta = -4 // Outputs[1] { @22E5 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_22EB: // Incoming call from 0x029E, returns to 0x029F // Inputs[2] // { // @22F0 stack[-1] // @22FB stack[-2] // } 22EB 5B JUMPDEST 22EC 60 PUSH1 0x00 22EE 60 PUSH1 0x20 22F0 82 DUP3 22F1 01 ADD 22F2 90 SWAP1 22F3 50 POP 22F4 61 PUSH2 0x2300 22F7 60 PUSH1 0x00 22F9 83 DUP4 22FA 01 ADD 22FB 84 DUP5 22FC 61 PUSH2 0x20b5 22FF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22F2 stack[0] = stack[-1] + 0x20 // @22F4 stack[1] = 0x2300 // @22FA stack[2] = stack[-1] + 0x00 // @22FB stack[3] = stack[-2] // } // Block ends with call to 0x20b5, returns to 0x2300 label_2300: // Incoming return from call to 0x20B5 at 0x22FF // Inputs[3] // { // @2301 stack[-4] // @2301 stack[-1] // @2302 stack[-3] // } 2300 5B JUMPDEST 2301 92 SWAP3 2302 91 SWAP2 2303 50 POP 2304 50 POP 2305 56 *JUMP // Stack delta = -3 // Outputs[1] { @2301 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2306: // Incoming call from 0x1F2F, returns to 0x1F30 // Inputs[2] // { // @2309 stack[-1] // @2312 stack[-2] // } 2306 5B JUMPDEST 2307 60 PUSH1 0x00 2309 81 DUP2 230A 90 SWAP1 230B 50 POP 230C 60 PUSH1 0x20 230E 82 DUP3 230F 01 ADD 2310 90 SWAP1 2311 50 POP 2312 91 SWAP2 2313 90 SWAP1 2314 50 POP 2315 56 *JUMP // Stack delta = -1 // Outputs[1] { @2312 stack[-2] = stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-2] label_2316: // Incoming call from 0x1F1A, returns to 0x1F1B // Inputs[3] // { // @2319 stack[-1] // @231A memory[stack[-1]:stack[-1] + 0x20] // @231D stack[-2] // } 2316 5B JUMPDEST 2317 60 PUSH1 0x00 2319 81 DUP2 231A 51 MLOAD 231B 90 SWAP1 231C 50 POP 231D 91 SWAP2 231E 90 SWAP1 231F 50 POP 2320 56 *JUMP // Stack delta = -1 // Outputs[1] { @231D stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_2321: // Incoming call from 0x1FA5, returns to 0x1FA6 // Inputs[3] // { // @2324 stack[-1] // @2325 memory[stack[-1]:stack[-1] + 0x20] // @2328 stack[-2] // } 2321 5B JUMPDEST 2322 60 PUSH1 0x00 2324 81 DUP2 2325 51 MLOAD 2326 90 SWAP1 2327 50 POP 2328 91 SWAP2 2329 90 SWAP1 232A 50 POP 232B 56 *JUMP // Stack delta = -1 // Outputs[1] { @2328 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_232C: // Incoming call from 0x1F52, returns to 0x1F53 // Inputs[2] // { // @2331 stack[-1] // @2335 stack[-2] // } 232C 5B JUMPDEST 232D 60 PUSH1 0x00 232F 60 PUSH1 0x20 2331 82 DUP3 2332 01 ADD 2333 90 SWAP1 2334 50 POP 2335 91 SWAP2 2336 90 SWAP1 2337 50 POP 2338 56 *JUMP // Stack delta = -1 // Outputs[1] { @2335 stack[-2] = stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-2] label_2339: // Incoming call from 0x1F24, returns to 0x1F25 // Inputs[3] // { // @233C stack[-2] // @233D stack[-1] // @2345 stack[-3] // } 2339 5B JUMPDEST 233A 60 PUSH1 0x00 233C 82 DUP3 233D 82 DUP3 233E 52 MSTORE 233F 60 PUSH1 0x20 2341 82 DUP3 2342 01 ADD 2343 90 SWAP1 2344 50 POP 2345 92 SWAP3 2346 91 SWAP2 2347 50 POP 2348 50 POP 2349 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @233E memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @2345 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_234A: // Incoming call from 0x208F, returns to 0x2090 // Inputs[3] // { // @234D stack[-1] // @2350 stack[-3] // @2351 stack[-2] // } 234A 5B JUMPDEST 234B 60 PUSH1 0x00 234D 81 DUP2 234E 90 SWAP1 234F 50 POP 2350 92 SWAP3 2351 91 SWAP2 2352 50 POP 2353 50 POP 2354 56 *JUMP // Stack delta = -2 // Outputs[1] { @2350 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2355: // Incoming call from 0x1FAF, returns to 0x1FB0 // Incoming call from 0x2049, returns to 0x204A // Incoming call from 0x206C, returns to 0x206D // Incoming call from 0x2026, returns to 0x2027 // Incoming call from 0x1FE0, returns to 0x1FE1 // Incoming call from 0x2003, returns to 0x2004 // Inputs[3] // { // @2358 stack[-2] // @2359 stack[-1] // @2361 stack[-3] // } 2355 5B JUMPDEST 2356 60 PUSH1 0x00 2358 82 DUP3 2359 82 DUP3 235A 52 MSTORE 235B 60 PUSH1 0x20 235D 82 DUP3 235E 01 ADD 235F 90 SWAP1 2360 50 POP 2361 92 SWAP3 2362 91 SWAP2 2363 50 POP 2364 50 POP 2365 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @235A memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @2361 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_2366: // Incoming call from 0x09BA, returns to 0x09BB // Incoming call from 0x1AD7, returns to 0x1AD8 // Incoming call from 0x0EDB, returns to 0x0EDC // Inputs[1] { @236C stack[-1] } 2366 5B JUMPDEST 2367 60 PUSH1 0x00 2369 61 PUSH2 0x2371 236C 82 DUP3 236D 61 PUSH2 0x24b9 2370 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2367 stack[0] = 0x00 // @2369 stack[1] = 0x2371 // @236C stack[2] = stack[-1] // } // Block ends with call to 0x24b9, returns to 0x2371 label_2371: // Incoming return from call to 0x24B9 at 0x2370 // Inputs[3] // { // @2372 stack[-1] // @2372 stack[-3] // @2377 stack[-4] // } 2371 5B JUMPDEST 2372 91 SWAP2 2373 50 POP 2374 61 PUSH2 0x237c 2377 83 DUP4 2378 61 PUSH2 0x24b9 237B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2372 stack[-3] = stack[-1] // @2374 stack[-1] = 0x237c // @2377 stack[0] = stack[-4] // } // Block ends with call to 0x24b9, returns to 0x237C label_237C: // Incoming return from call to 0x24B9 at 0x237B // Inputs[3] // { // @237D stack[-1] // @237D stack[-4] // @23A2 stack[-3] // } 237C 5B JUMPDEST 237D 92 SWAP3 237E 50 POP 237F 82 DUP3 2380 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 23A1 03 SUB 23A2 82 DUP3 23A3 11 GT 23A4 15 ISZERO 23A5 61 PUSH2 0x23b1 23A8 57 *JUMPI // Stack delta = -1 // Outputs[1] { @237D stack[-4] = stack[-1] } // Block ends with conditional jump to 0x23b1, if !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) label_23A9: // Incoming jump from 0x23A8, if not !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) 23A9 61 PUSH2 0x23b0 23AC 61 PUSH2 0x2539 23AF 56 *JUMP // Stack delta = +1 // Outputs[1] { @23A9 stack[0] = 0x23b0 } // Block ends with unconditional jump to 0x2539 23B0 5B JUMPDEST label_23B1: // Incoming jump from 0x23A8, if !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) // Inputs[4] // { // @23B2 stack[-3] // @23B3 stack[-2] // @23B5 stack[-1] // @23B7 stack[-4] // } 23B1 5B JUMPDEST 23B2 82 DUP3 23B3 82 DUP3 23B4 01 ADD 23B5 90 SWAP1 23B6 50 POP 23B7 92 SWAP3 23B8 91 SWAP2 23B9 50 POP 23BA 50 POP 23BB 56 *JUMP // Stack delta = -3 // Outputs[1] { @23B7 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_23BC: // Incoming call from 0x0CCD, returns to 0x0CCE // Incoming call from 0x1C8B, returns to 0x1C8C // Incoming call from 0x1B56, returns to 0x1B57 // Inputs[1] { @23C2 stack[-1] } 23BC 5B JUMPDEST 23BD 60 PUSH1 0x00 23BF 61 PUSH2 0x23c7 23C2 82 DUP3 23C3 61 PUSH2 0x24b9 23C6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23BD stack[0] = 0x00 // @23BF stack[1] = 0x23c7 // @23C2 stack[2] = stack[-1] // } // Block ends with call to 0x24b9, returns to 0x23C7 label_23C7: // Incoming return from call to 0x24B9 at 0x23C6 // Inputs[3] // { // @23C8 stack[-1] // @23C8 stack[-3] // @23CD stack[-4] // } 23C7 5B JUMPDEST 23C8 91 SWAP2 23C9 50 POP 23CA 61 PUSH2 0x23d2 23CD 83 DUP4 23CE 61 PUSH2 0x24b9 23D1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @23C8 stack[-3] = stack[-1] // @23CA stack[-1] = 0x23d2 // @23CD stack[0] = stack[-4] // } // Block ends with call to 0x24b9, returns to 0x23D2 label_23D2: // Incoming return from call to 0x24B9 at 0x23D1 // Inputs[2] // { // @23D3 stack[-1] // @23D3 stack[-4] // } 23D2 5B JUMPDEST 23D3 92 SWAP3 23D4 50 POP 23D5 82 DUP3 23D6 61 PUSH2 0x23e2 23D9 57 *JUMPI // Stack delta = -1 // Outputs[1] { @23D3 stack[-4] = stack[-1] } // Block ends with conditional jump to 0x23e2, if stack[-1] label_23DA: // Incoming jump from 0x23D9, if not stack[-1] 23DA 61 PUSH2 0x23e1 23DD 61 PUSH2 0x2568 23E0 56 *JUMP // Stack delta = +1 // Outputs[1] { @23DA stack[0] = 0x23e1 } // Block ends with unconditional jump to 0x2568 23E1 5B JUMPDEST label_23E2: // Incoming jump from 0x23D9, if stack[-1] // Inputs[4] // { // @23E3 stack[-3] // @23E4 stack[-2] // @23E6 stack[-1] // @23E8 stack[-4] // } 23E2 5B JUMPDEST 23E3 82 DUP3 23E4 82 DUP3 23E5 04 DIV 23E6 90 SWAP1 23E7 50 POP 23E8 92 SWAP3 23E9 91 SWAP2 23EA 50 POP 23EB 50 POP 23EC 56 *JUMP // Stack delta = -3 // Outputs[1] { @23E8 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_23ED: // Incoming call from 0x1B47, returns to 0x1B48 // Incoming call from 0x0CC3, returns to 0x0CC4 // Inputs[1] { @23F3 stack[-1] } 23ED 5B JUMPDEST 23EE 60 PUSH1 0x00 23F0 61 PUSH2 0x23f8 23F3 82 DUP3 23F4 61 PUSH2 0x24b9 23F7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23EE stack[0] = 0x00 // @23F0 stack[1] = 0x23f8 // @23F3 stack[2] = stack[-1] // } // Block ends with call to 0x24b9, returns to 0x23F8 label_23F8: // Incoming return from call to 0x24B9 at 0x23F7 // Inputs[3] // { // @23F9 stack[-1] // @23F9 stack[-3] // @23FE stack[-4] // } 23F8 5B JUMPDEST 23F9 91 SWAP2 23FA 50 POP 23FB 61 PUSH2 0x2403 23FE 83 DUP4 23FF 61 PUSH2 0x24b9 2402 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @23F9 stack[-3] = stack[-1] // @23FB stack[-1] = 0x2403 // @23FE stack[0] = stack[-4] // } // Block ends with call to 0x24b9, returns to 0x2403 label_2403: // Incoming return from call to 0x24B9 at 0x2402 // Inputs[3] // { // @2404 stack[-4] // @2404 stack[-1] // @2406 stack[-3] // } 2403 5B JUMPDEST 2404 92 SWAP3 2405 50 POP 2406 81 DUP2 2407 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2428 04 DIV 2429 83 DUP4 242A 11 GT 242B 82 DUP3 242C 15 ISZERO 242D 15 ISZERO 242E 16 AND 242F 15 ISZERO 2430 61 PUSH2 0x243c 2433 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2404 stack[-4] = stack[-1] } // Block ends with conditional jump to 0x243c, if !(!!stack[-3] & (stack[-1] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / stack[-3])) label_2434: // Incoming jump from 0x2433, if not !(!!stack[-3] & (stack[-1] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / stack[-3])) 2434 61 PUSH2 0x243b 2437 61 PUSH2 0x2539 243A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2434 stack[0] = 0x243b } // Block ends with unconditional jump to 0x2539 243B 5B JUMPDEST label_243C: // Incoming jump from 0x2433, if !(!!stack[-3] & (stack[-1] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / stack[-3])) // Inputs[4] // { // @243D stack[-3] // @243E stack[-2] // @2440 stack[-1] // @2442 stack[-4] // } 243C 5B JUMPDEST 243D 82 DUP3 243E 82 DUP3 243F 02 MUL 2440 90 SWAP1 2441 50 POP 2442 92 SWAP3 2443 91 SWAP2 2444 50 POP 2445 50 POP 2446 56 *JUMP // Stack delta = -3 // Outputs[1] { @2442 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_2447: // Incoming call from 0x0D53, returns to 0x0D54 // Inputs[1] { @244D stack[-1] } 2447 5B JUMPDEST 2448 60 PUSH1 0x00 244A 61 PUSH2 0x2452 244D 82 DUP3 244E 61 PUSH2 0x24b9 2451 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2448 stack[0] = 0x00 // @244A stack[1] = 0x2452 // @244D stack[2] = stack[-1] // } // Block ends with call to 0x24b9, returns to 0x2452 label_2452: // Incoming return from call to 0x24B9 at 0x2451 // Inputs[3] // { // @2453 stack[-3] // @2453 stack[-1] // @2458 stack[-4] // } 2452 5B JUMPDEST 2453 91 SWAP2 2454 50 POP 2455 61 PUSH2 0x245d 2458 83 DUP4 2459 61 PUSH2 0x24b9 245C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2453 stack[-3] = stack[-1] // @2455 stack[-1] = 0x245d // @2458 stack[0] = stack[-4] // } // Block ends with call to 0x24b9, returns to 0x245D label_245D: // Incoming return from call to 0x24B9 at 0x245C // Inputs[3] // { // @245E stack[-1] // @245E stack[-4] // @2461 stack[-3] // } 245D 5B JUMPDEST 245E 92 SWAP3 245F 50 POP 2460 82 DUP3 2461 82 DUP3 2462 10 LT 2463 15 ISZERO 2464 61 PUSH2 0x2470 2467 57 *JUMPI // Stack delta = -1 // Outputs[1] { @245E stack[-4] = stack[-1] } // Block ends with conditional jump to 0x2470, if !(stack[-3] < stack[-1]) label_2468: // Incoming jump from 0x2467, if not !(stack[-3] < stack[-1]) 2468 61 PUSH2 0x246f 246B 61 PUSH2 0x2539 246E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2468 stack[0] = 0x246f } // Block ends with unconditional jump to 0x2539 246F 5B JUMPDEST label_2470: // Incoming jump from 0x2467, if !(stack[-3] < stack[-1]) // Inputs[4] // { // @2471 stack[-3] // @2472 stack[-2] // @2474 stack[-1] // @2476 stack[-4] // } 2470 5B JUMPDEST 2471 82 DUP3 2472 82 DUP3 2473 03 SUB 2474 90 SWAP1 2475 50 POP 2476 92 SWAP3 2477 91 SWAP2 2478 50 POP 2479 50 POP 247A 56 *JUMP // Stack delta = -3 // Outputs[1] { @2476 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_247B: // Incoming call from 0x272F, returns to 0x2730 // Incoming call from 0x1EFA, returns to 0x1EFB // Incoming call from 0x1F09, returns to 0x1F0A // Inputs[1] { @2481 stack[-1] } 247B 5B JUMPDEST 247C 60 PUSH1 0x00 247E 61 PUSH2 0x2486 2481 82 DUP3 2482 61 PUSH2 0x2499 2485 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @247C stack[0] = 0x00 // @247E stack[1] = 0x2486 // @2481 stack[2] = stack[-1] // } // Block ends with call to 0x2499, returns to 0x2486 label_2486: // Incoming return from call to 0x2499 at 0x2485 // Inputs[4] // { // @2487 stack[-1] // @2487 stack[-2] // @2489 stack[-4] // @248A stack[-3] // } 2486 5B JUMPDEST 2487 90 SWAP1 2488 50 POP 2489 91 SWAP2 248A 90 SWAP1 248B 50 POP 248C 56 *JUMP // Stack delta = -3 // Outputs[1] { @2489 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_248D: // Incoming call from 0x1F76, returns to 0x1F77 // Inputs[2] // { // @2490 stack[-1] // @2495 stack[-2] // } 248D 5B JUMPDEST 248E 60 PUSH1 0x00 2490 81 DUP2 2491 15 ISZERO 2492 15 ISZERO 2493 90 SWAP1 2494 50 POP 2495 91 SWAP2 2496 90 SWAP1 2497 50 POP 2498 56 *JUMP // Stack delta = -1 // Outputs[1] { @2495 stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_2499: // Incoming call from 0x24EC, returns to 0x24ED // Incoming call from 0x2485, returns to 0x2486 // Inputs[2] // { // @24B1 stack[-1] // @24B5 stack[-2] // } 2499 5B JUMPDEST 249A 60 PUSH1 0x00 249C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24B1 82 DUP3 24B2 16 AND 24B3 90 SWAP1 24B4 50 POP 24B5 91 SWAP2 24B6 90 SWAP1 24B7 50 POP 24B8 56 *JUMP // Stack delta = -1 // Outputs[1] { @24B5 stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-2] label_24B9: // Incoming call from 0x237B, returns to 0x237C // Incoming call from 0x23C6, returns to 0x23C7 // Incoming call from 0x2370, returns to 0x2371 // Incoming call from 0x24FE, returns to 0x24FF // Incoming call from 0x2402, returns to 0x2403 // Incoming call from 0x20AE, returns to 0x20AF // Incoming call from 0x2746, returns to 0x2747 // Incoming call from 0x245C, returns to 0x245D // Incoming call from 0x2451, returns to 0x2452 // Incoming call from 0x23F7, returns to 0x23F8 // Incoming call from 0x23D1, returns to 0x23D2 // Inputs[2] // { // @24BC stack[-1] // @24BF stack[-2] // } 24B9 5B JUMPDEST 24BA 60 PUSH1 0x00 24BC 81 DUP2 24BD 90 SWAP1 24BE 50 POP 24BF 91 SWAP2 24C0 90 SWAP1 24C1 50 POP 24C2 56 *JUMP // Stack delta = -1 // Outputs[1] { @24BF stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_24C3: // Incoming call from 0x20BD, returns to 0x20BE // Inputs[2] // { // @24C8 stack[-1] // @24CC stack[-2] // } 24C3 5B JUMPDEST 24C4 60 PUSH1 0x00 24C6 60 PUSH1 0xff 24C8 82 DUP3 24C9 16 AND 24CA 90 SWAP1 24CB 50 POP 24CC 91 SWAP2 24CD 90 SWAP1 24CE 50 POP 24CF 56 *JUMP // Stack delta = -1 // Outputs[1] { @24CC stack[-2] = stack[-1] & 0xff } // Block ends with unconditional jump to stack[-2] label_24D0: // Incoming call from 0x1F85, returns to 0x1F86 // Inputs[1] { @24D6 stack[-1] } 24D0 5B JUMPDEST 24D1 60 PUSH1 0x00 24D3 61 PUSH2 0x24db 24D6 82 DUP3 24D7 61 PUSH2 0x24e2 24DA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24D1 stack[0] = 0x00 // @24D3 stack[1] = 0x24db // @24D6 stack[2] = stack[-1] // } // Block ends with call to 0x24e2, returns to 0x24DB label_24DB: // Incoming return from call to 0x24E2 at 0x24DA // Inputs[4] // { // @24DC stack[-2] // @24DC stack[-1] // @24DE stack[-4] // @24DF stack[-3] // } 24DB 5B JUMPDEST 24DC 90 SWAP1 24DD 50 POP 24DE 91 SWAP2 24DF 90 SWAP1 24E0 50 POP 24E1 56 *JUMP // Stack delta = -3 // Outputs[1] { @24DE stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_24E2: // Incoming call from 0x24DA, returns to 0x24DB // Inputs[1] { @24E8 stack[-1] } 24E2 5B JUMPDEST 24E3 60 PUSH1 0x00 24E5 61 PUSH2 0x24ed 24E8 82 DUP3 24E9 61 PUSH2 0x2499 24EC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24E3 stack[0] = 0x00 // @24E5 stack[1] = 0x24ed // @24E8 stack[2] = stack[-1] // } // Block ends with call to 0x2499, returns to 0x24ED label_24ED: // Incoming return from call to 0x2499 at 0x24EC // Inputs[4] // { // @24EE stack[-2] // @24EE stack[-1] // @24F0 stack[-4] // @24F1 stack[-3] // } 24ED 5B JUMPDEST 24EE 90 SWAP1 24EF 50 POP 24F0 91 SWAP2 24F1 90 SWAP1 24F2 50 POP 24F3 56 *JUMP // Stack delta = -3 // Outputs[1] { @24F0 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_24F4: // Incoming call from 0x1F94, returns to 0x1F95 // Inputs[1] { @24FA stack[-1] } 24F4 5B JUMPDEST 24F5 60 PUSH1 0x00 24F7 61 PUSH2 0x24ff 24FA 82 DUP3 24FB 61 PUSH2 0x24b9 24FE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24F5 stack[0] = 0x00 // @24F7 stack[1] = 0x24ff // @24FA stack[2] = stack[-1] // } // Block ends with call to 0x24b9, returns to 0x24FF label_24FF: // Incoming return from call to 0x24B9 at 0x24FE // Inputs[4] // { // @2500 stack[-1] // @2500 stack[-2] // @2502 stack[-4] // @2503 stack[-3] // } 24FF 5B JUMPDEST 2500 90 SWAP1 2501 50 POP 2502 91 SWAP2 2503 90 SWAP1 2504 50 POP 2505 56 *JUMP // Stack delta = -3 // Outputs[1] { @2502 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2506: // Incoming call from 0x1FBF, returns to 0x1FC0 // Inputs[1] { @250A stack[-3] } 2506 5B JUMPDEST 2507 60 PUSH1 0x00 2509 5B JUMPDEST 250A 83 DUP4 250B 81 DUP2 250C 10 LT 250D 15 ISZERO 250E 61 PUSH2 0x2524 2511 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2507 stack[0] = 0x00 } // Block ends with conditional jump to 0x2524, if !(0x00 < stack[-3]) label_2512: // Incoming jump from 0x2511, if not !(0x00 < stack[-3]) // Incoming jump from 0x2511, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2512 stack[-1] // @2513 stack[-2] // @2515 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2517 stack[-3] // } 2512 80 DUP1 2513 82 DUP3 2514 01 ADD 2515 51 MLOAD 2516 81 DUP2 2517 84 DUP5 2518 01 ADD 2519 52 MSTORE 251A 60 PUSH1 0x20 251C 81 DUP2 251D 01 ADD 251E 90 SWAP1 251F 50 POP 2520 61 PUSH2 0x2509 2523 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2519 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @251E stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2509 label_2524: // Incoming jump from 0x2511, if !(0x00 < stack[-3]) // Incoming jump from 0x2511, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @2525 stack[-4] // @2526 stack[-1] // } 2524 5B JUMPDEST 2525 83 DUP4 2526 81 DUP2 2527 11 GT 2528 15 ISZERO 2529 61 PUSH2 0x2533 252C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2533, if !(stack[-1] > stack[-4]) label_252D: // Incoming jump from 0x252C, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @252F stack[-4] // @2530 stack[-3] // @2538 stack[-5] // } 252D 60 PUSH1 0x00 252F 84 DUP5 2530 84 DUP5 2531 01 ADD 2532 52 MSTORE 2533 5B JUMPDEST 2534 50 POP 2535 50 POP 2536 50 POP 2537 50 POP 2538 56 *JUMP // Stack delta = -5 // Outputs[1] { @2532 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2539: // Incoming jump from 0x23AF // Incoming jump from 0x246E // Incoming jump from 0x243A // Inputs[1] { @2567 memory[0x00:0x24] } 2539 5B JUMPDEST 253A 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 255B 60 PUSH1 0x00 255D 52 MSTORE 255E 60 PUSH1 0x11 2560 60 PUSH1 0x04 2562 52 MSTORE 2563 60 PUSH1 0x24 2565 60 PUSH1 0x00 2567 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @255D memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2562 memory[0x04:0x24] = 0x11 // @2567 revert(memory[0x00:0x24]); // } // Block terminates label_2568: // Incoming jump from 0x23E0 // Inputs[1] { @2596 memory[0x00:0x24] } 2568 5B JUMPDEST 2569 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 258A 60 PUSH1 0x00 258C 52 MSTORE 258D 60 PUSH1 0x12 258F 60 PUSH1 0x04 2591 52 MSTORE 2592 60 PUSH1 0x24 2594 60 PUSH1 0x00 2596 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @258C memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2591 memory[0x04:0x24] = 0x12 // @2596 revert(memory[0x00:0x24]); // } // Block terminates label_2597: // Incoming jump from 0x14AE // Incoming jump from 0x159C // Inputs[1] { @25C5 memory[0x00:0x24] } 2597 5B JUMPDEST 2598 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 25B9 60 PUSH1 0x00 25BB 52 MSTORE 25BC 60 PUSH1 0x32 25BE 60 PUSH1 0x04 25C0 52 MSTORE 25C1 60 PUSH1 0x24 25C3 60 PUSH1 0x00 25C5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @25BB memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @25C0 memory[0x04:0x24] = 0x32 // @25C5 revert(memory[0x00:0x24]); // } // Block terminates label_25C6: // Incoming jump from 0x1468 // Inputs[1] { @25F4 memory[0x00:0x24] } 25C6 5B JUMPDEST 25C7 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 25E8 60 PUSH1 0x00 25EA 52 MSTORE 25EB 60 PUSH1 0x41 25ED 60 PUSH1 0x04 25EF 52 MSTORE 25F0 60 PUSH1 0x24 25F2 60 PUSH1 0x00 25F4 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @25EA memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @25EF memory[0x04:0x24] = 0x41 // @25F4 revert(memory[0x00:0x24]); // } // Block terminates label_25F5: // Incoming jump from 0x1E5C // Incoming jump from 0x1D2E // Incoming jump from 0x1E9E // Incoming jump from 0x1E2E // Incoming jump from 0x1D5C // Incoming jump from 0x1D9E // Incoming jump from 0x1DEF // Incoming jump from 0x1D01 // Inputs[1] { @25F9 memory[0x00:0x00] } 25F5 5B JUMPDEST 25F6 60 PUSH1 0x00 25F8 80 DUP1 25F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @25F9 revert(memory[0x00:0x00]); } // Block terminates label_25FA: // Incoming call from 0x1FC8, returns to 0x1FC9 // Inputs[2] // { // @2602 stack[-1] // @2607 stack[-2] // } 25FA 5B JUMPDEST 25FB 60 PUSH1 0x00 25FD 60 PUSH1 0x1f 25FF 19 NOT 2600 60 PUSH1 0x1f 2602 83 DUP4 2603 01 ADD 2604 16 AND 2605 90 SWAP1 2606 50 POP 2607 91 SWAP2 2608 90 SWAP1 2609 50 POP 260A 56 *JUMP // Stack delta = -1 // Outputs[1] { @2607 stack[-2] = stack[-1] + 0x1f & ~0x1f } // Block ends with unconditional jump to stack[-2] label_260B: // Incoming call from 0x1FEB, returns to 0x1FEC // Inputs[2] // { // @262F stack[-1] // @2659 stack[-2] // } 260B 5B JUMPDEST 260C 7F PUSH32 0x5472616e7366657220616d6f756e742065786365656473207468652062616720 262D 60 PUSH1 0x00 262F 82 DUP3 2630 01 ADD 2631 52 MSTORE 2632 7F PUSH32 0x73697a652e000000000000000000000000000000000000000000000000000000 2653 60 PUSH1 0x20 2655 82 DUP3 2656 01 ADD 2657 52 MSTORE 2658 50 POP 2659 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2631 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x5472616e7366657220616d6f756e742065786365656473207468652062616720 // @2657 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x73697a652e000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_265A: // Incoming call from 0x200E, returns to 0x200F // Inputs[2] // { // @267E stack[-1] // @2682 stack[-2] // } 265A 5B JUMPDEST 265B 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 267C 60 PUSH1 0x00 267E 82 DUP3 267F 01 ADD 2680 52 MSTORE 2681 50 POP 2682 56 *JUMP // Stack delta = -2 // Outputs[1] { @2680 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 } // Block ends with unconditional jump to stack[-2] label_2683: // Incoming call from 0x2031, returns to 0x2032 // Inputs[2] // { // @26A7 stack[-1] // @26AB stack[-2] // } 2683 5B JUMPDEST 2684 7F PUSH32 0x72656365697665722072656a656374656420455448207472616e736665720000 26A5 60 PUSH1 0x00 26A7 82 DUP3 26A8 01 ADD 26A9 52 MSTORE 26AA 50 POP 26AB 56 *JUMP // Stack delta = -2 // Outputs[1] { @26A9 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x72656365697665722072656a656374656420455448207472616e736665720000 } // Block ends with unconditional jump to stack[-2] label_26AC: // Incoming call from 0x2054, returns to 0x2055 // Inputs[2] // { // @26D0 stack[-1] // @26FA stack[-2] // } 26AC 5B JUMPDEST 26AD 7F PUSH32 0x536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f 26CE 60 PUSH1 0x00 26D0 82 DUP3 26D1 01 ADD 26D2 52 MSTORE 26D3 7F PUSH32 0x7700000000000000000000000000000000000000000000000000000000000000 26F4 60 PUSH1 0x20 26F6 82 DUP3 26F7 01 ADD 26F8 52 MSTORE 26F9 50 POP 26FA 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @26D2 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f // @26F8 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7700000000000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_26FB: // Incoming call from 0x2077, returns to 0x2078 // Inputs[2] // { // @271F stack[-1] // @2723 stack[-2] // } 26FB 5B JUMPDEST 26FC 7F PUSH32 0x214f574e45520000000000000000000000000000000000000000000000000000 271D 60 PUSH1 0x00 271F 82 DUP3 2720 01 ADD 2721 52 MSTORE 2722 50 POP 2723 56 *JUMP // Stack delta = -2 // Outputs[1] { @2721 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x214f574e45520000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_2724: // Incoming call from 0x209A, returns to 0x209B // Inputs[1] { @2726 stack[-2] } 2724 5B JUMPDEST 2725 50 POP 2726 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_2727: // Incoming call from 0x1CBC, returns to 0x1CBD // Incoming call from 0x1CA7, returns to 0x1CA8 // Inputs[1] { @272B stack[-1] } 2727 5B JUMPDEST 2728 61 PUSH2 0x2730 272B 81 DUP2 272C 61 PUSH2 0x247b 272F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2728 stack[0] = 0x2730 // @272B stack[1] = stack[-1] // } // Block ends with call to 0x247b, returns to 0x2730 label_2730: // Incoming return from call to 0x247B at 0x272F // Inputs[2] // { // @2731 stack[-2] // @2732 stack[-1] // } 2730 5B JUMPDEST 2731 81 DUP2 2732 14 EQ 2733 61 PUSH2 0x273b 2736 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x273b, if stack[-2] == stack[-1] label_2737: // Incoming jump from 0x2736, if not stack[-2] == stack[-1] // Inputs[1] { @273A memory[0x00:0x00] } 2737 60 PUSH1 0x00 2739 80 DUP1 273A FD *REVERT // Stack delta = +0 // Outputs[1] { @273A revert(memory[0x00:0x00]); } // Block terminates label_273B: // Incoming jump from 0x2736, if stack[-2] == stack[-1] // Inputs[1] { @273D stack[-2] } 273B 5B JUMPDEST 273C 50 POP 273D 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_273E: // Incoming call from 0x1CE6, returns to 0x1CE7 // Incoming call from 0x1CD1, returns to 0x1CD2 // Inputs[1] { @2742 stack[-1] } 273E 5B JUMPDEST 273F 61 PUSH2 0x2747 2742 81 DUP2 2743 61 PUSH2 0x24b9 2746 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @273F stack[0] = 0x2747 // @2742 stack[1] = stack[-1] // } // Block ends with call to 0x24b9, returns to 0x2747 label_2747: // Incoming return from call to 0x24B9 at 0x2746 // Inputs[2] // { // @2748 stack[-2] // @2749 stack[-1] // } 2747 5B JUMPDEST 2748 81 DUP2 2749 14 EQ 274A 61 PUSH2 0x2752 274D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2752, if stack[-2] == stack[-1] label_274E: // Incoming jump from 0x274D, if not stack[-2] == stack[-1] // Inputs[1] { @2751 memory[0x00:0x00] } 274E 60 PUSH1 0x00 2750 80 DUP1 2751 FD *REVERT // Stack delta = +0 // Outputs[1] { @2751 revert(memory[0x00:0x00]); } // Block terminates label_2752: // Incoming jump from 0x274D, if stack[-2] == stack[-1] // Inputs[1] { @2754 stack[-2] } 2752 5B JUMPDEST 2753 50 POP 2754 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 2755 FE *ASSERT 2756 A2 LOG2 2757 64 PUSH5 0x6970667358 275D 22 22 275E 12 SLT 275F 20 SHA3 2760 E9 E9 2761 EE EE 2762 EB EB 2763 F9 F9 2764 CD CD 2765 C3 C3 2766 EB EB 2767 41 COINBASE 2768 FE *ASSERT 2769 F7 F7 276A D2 D2 276B 75 PUSH22 0xb7cacfc8b80ae30ff7597d22e6520c34cb41224a6473 2782 6F PUSH16 0x6c63430008050033