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 0x012e 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x012e, 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 0x8dd95002 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 0x8dd95002 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x8dd95002 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xba6f43e6 0024 11 GT 0025 61 PUSH2 0x006f 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xba6f43e6 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xba6f43e6 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xba6f43e6 002F 14 EQ 0030 61 PUSH2 0x04c8 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c8, if 0xba6f43e6 == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xba6f43e6 == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xcc1d399f 003A 14 EQ 003B 61 PUSH2 0x04f3 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f3, if 0xcc1d399f == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xcc1d399f == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xd8181949 0045 14 EQ 0046 61 PUSH2 0x051e 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051e, if 0xd8181949 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xd8181949 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xdd62ed3e 0050 14 EQ 0051 61 PUSH2 0x0549 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0549, if 0xdd62ed3e == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xeb325cc7 005B 14 EQ 005C 61 PUSH2 0x0586 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0586, if 0xeb325cc7 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xeb325cc7 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf1493490 0066 14 EQ 0067 61 PUSH2 0x059d 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x059d, if 0xf1493490 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf1493490 == stack[-1] 006B 61 PUSH2 0x01c0 006E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c0 label_006F: // Incoming jump from 0x0028, if 0xba6f43e6 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0x8dd95002 0076 14 EQ 0077 61 PUSH2 0x03cd 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cd, if 0x8dd95002 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x8dd95002 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0x91cca3db 0081 14 EQ 0082 61 PUSH2 0x03f8 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f8, if 0x91cca3db == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0x91cca3db == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0x95d89b41 008C 14 EQ 008D 61 PUSH2 0x0423 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0423, if 0x95d89b41 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xa457c2d7 0097 14 EQ 0098 61 PUSH2 0x044e 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044e, if 0xa457c2d7 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xa457c2d7 == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xa9059cbb 00A2 14 EQ 00A3 61 PUSH2 0x048b 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048b, if 0xa9059cbb == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xa9059cbb == stack[-1] 00A7 61 PUSH2 0x01c0 00AA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c0 label_00AB: // Incoming jump from 0x001D, if 0x8dd95002 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00AC stack[-1] } 00AB 5B JUMPDEST 00AC 80 DUP1 00AD 63 PUSH4 0x23b872dd 00B2 11 GT 00B3 61 PUSH2 0x00f2 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f2, if 0x23b872dd > stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x23b872dd > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x23b872dd 00BD 14 EQ 00BE 61 PUSH2 0x02c0 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c0, if 0x23b872dd == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x23b872dd == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x313ce567 00C8 14 EQ 00C9 61 PUSH2 0x02fd 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fd, 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 0x39509351 00D3 14 EQ 00D4 61 PUSH2 0x0328 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0328, if 0x39509351 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x39509351 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0x49bd5a5e 00DE 14 EQ 00DF 61 PUSH2 0x0365 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0365, if 0x49bd5a5e == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0x49bd5a5e == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0x70a08231 00E9 14 EQ 00EA 61 PUSH2 0x0390 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0390, if 0x70a08231 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0x70a08231 == stack[-1] 00EE 61 PUSH2 0x01c0 00F1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c0 label_00F2: // Incoming jump from 0x00B6, if 0x23b872dd > stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F2 5B JUMPDEST 00F3 80 DUP1 00F4 63 PUSH4 0x03fd2a45 00F9 14 EQ 00FA 61 PUSH2 0x01c5 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c5, if 0x03fd2a45 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x03fd2a45 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x0520b708 0104 14 EQ 0105 61 PUSH2 0x01f0 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f0, if 0x0520b708 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x0520b708 == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x06fdde03 010F 14 EQ 0110 61 PUSH2 0x022d 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022d, 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 0x0258 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0258, 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 0x0295 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0295, if 0x18160ddd == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x18160ddd == stack[-1] 012A 61 PUSH2 0x01c0 012D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c0 label_012E: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @012F msg.data.length } 012E 5B JUMPDEST 012F 36 CALLDATASIZE 0130 61 PUSH2 0x01c0 0133 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c0, if msg.data.length label_0134: // Incoming jump from 0x0133, if not msg.data.length // Inputs[3] // { // @0139 storage[0x03] // @016D msg.value // @0170 memory[0x40:0x60] // } 0134 60 PUSH1 0x03 0136 60 PUSH1 0x00 0138 90 SWAP1 0139 54 SLOAD 013A 90 SWAP1 013B 61 PUSH2 0x0100 013E 0A EXP 013F 90 SWAP1 0140 04 DIV 0141 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0156 16 AND 0157 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 016C 16 AND 016D 34 CALLVALUE 016E 60 PUSH1 0x40 0170 51 MLOAD 0171 61 PUSH2 0x0179 0174 90 SWAP1 0175 61 PUSH2 0x1c3e 0178 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @016C stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00 // @016D stack[1] = msg.value // @0174 stack[2] = 0x0179 // @0174 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1c3e, returns to 0x0179 label_0179: // Incoming return from call to 0x1C3E at 0x0178 // Inputs[8] // { // @017E memory[0x40:0x60] // @0180 stack[-1] // @0183 stack[-2] // @0184 stack[-3] // @0185 msg.gas // @0186 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0186 address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @018B returndata.length // } 0179 5B JUMPDEST 017A 60 PUSH1 0x00 017C 60 PUSH1 0x40 017E 51 MLOAD 017F 80 DUP1 0180 83 DUP4 0181 03 SUB 0182 81 DUP2 0183 85 DUP6 0184 87 DUP8 0185 5A GAS 0186 F1 CALL 0187 92 SWAP3 0188 50 POP 0189 50 POP 018A 50 POP 018B 3D RETURNDATASIZE 018C 80 DUP1 018D 60 PUSH1 0x00 018F 81 DUP2 0190 14 EQ 0191 61 PUSH2 0x01b6 0194 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0186 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0187 stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @018B stack[-2] = returndata.length // @018C stack[-1] = returndata.length // } // Block ends with conditional jump to 0x01b6, if returndata.length == 0x00 label_0195: // Incoming jump from 0x0194, if not returndata.length == 0x00 // Inputs[6] // { // @0197 memory[0x40:0x60] // @0198 stack[-2] // @019F returndata.length // @01A7 returndata.length // @01AA returndata.length // @01B1 returndata[0x00:0x00 + returndata.length] // } 0195 60 PUSH1 0x40 0197 51 MLOAD 0198 91 SWAP2 0199 50 POP 019A 60 PUSH1 0x1f 019C 19 NOT 019D 60 PUSH1 0x3f 019F 3D RETURNDATASIZE 01A0 01 ADD 01A1 16 AND 01A2 82 DUP3 01A3 01 ADD 01A4 60 PUSH1 0x40 01A6 52 MSTORE 01A7 3D RETURNDATASIZE 01A8 82 DUP3 01A9 52 MSTORE 01AA 3D RETURNDATASIZE 01AB 60 PUSH1 0x00 01AD 60 PUSH1 0x20 01AF 84 DUP5 01B0 01 ADD 01B1 3E RETURNDATACOPY 01B2 61 PUSH2 0x01bb 01B5 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0198 stack[-2] = memory[0x40:0x60] // @01A6 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @01A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @01B1 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x01bb label_01B6: // Incoming jump from 0x0194, if returndata.length == 0x00 // Inputs[1] { @01B9 stack[-2] } 01B6 5B JUMPDEST 01B7 60 PUSH1 0x60 01B9 91 SWAP2 01BA 50 POP 01BB 5B JUMPDEST 01BC 50 POP 01BD 50 POP 01BE 50 POP 01BF 00 *STOP // Stack delta = -3 // Outputs[1] { @01BF stop(); } // Block terminates label_01C0: // Incoming jump from 0x00AA // Incoming jump from 0x006E // Incoming jump from 0x0133, if msg.data.length // Incoming jump from 0x012D // Incoming jump from 0x00F1 // Inputs[1] { @01C4 memory[0x00:0x00] } 01C0 5B JUMPDEST 01C1 60 PUSH1 0x00 01C3 80 DUP1 01C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C4 revert(memory[0x00:0x00]); } // Block terminates label_01C5: // Incoming jump from 0x00FD, if 0x03fd2a45 == stack[-1] // Inputs[1] { @01C6 msg.value } 01C5 5B JUMPDEST 01C6 34 CALLVALUE 01C7 80 DUP1 01C8 15 ISZERO 01C9 61 PUSH2 0x01d1 01CC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01C6 stack[0] = msg.value } // Block ends with conditional jump to 0x01d1, if !msg.value label_01CD: // Incoming jump from 0x01CC, if not !msg.value // Inputs[1] { @01D0 memory[0x00:0x00] } 01CD 60 PUSH1 0x00 01CF 80 DUP1 01D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D0 revert(memory[0x00:0x00]); } // Block terminates label_01D1: // Incoming jump from 0x01CC, if !msg.value 01D1 5B JUMPDEST 01D2 50 POP 01D3 61 PUSH2 0x01da 01D6 61 PUSH2 0x05da 01D9 56 *JUMP // Stack delta = +0 // Outputs[1] { @01D3 stack[-1] = 0x01da } // Block ends with call to 0x05da, returns to 0x01DA label_01DA: // Incoming return from call to 0x05DA at 0x01D9 // Inputs[2] // { // @01DD memory[0x40:0x60] // @01E1 stack[-1] // } 01DA 5B JUMPDEST 01DB 60 PUSH1 0x40 01DD 51 MLOAD 01DE 61 PUSH2 0x01e7 01E1 91 SWAP2 01E2 90 SWAP1 01E3 61 PUSH2 0x1c53 01E6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01E1 stack[-1] = 0x01e7 // @01E2 stack[1] = memory[0x40:0x60] // @01E2 stack[0] = stack[-1] // } // Block ends with call to 0x1c53, returns to 0x01E7 label_01E7: // Incoming return from call to 0x1C53 at 0x01E6 // Inputs[3] // { // @01EA memory[0x40:0x60] // @01EC stack[-1] // @01EF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01E7 5B JUMPDEST 01E8 60 PUSH1 0x40 01EA 51 MLOAD 01EB 80 DUP1 01EC 91 SWAP2 01ED 03 SUB 01EE 90 SWAP1 01EF F3 *RETURN // Stack delta = -1 // Outputs[1] { @01EF return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01F0: // Incoming jump from 0x0108, if 0x0520b708 == stack[-1] // Inputs[1] { @01F1 msg.value } 01F0 5B JUMPDEST 01F1 34 CALLVALUE 01F2 80 DUP1 01F3 15 ISZERO 01F4 61 PUSH2 0x01fc 01F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01F1 stack[0] = msg.value } // Block ends with conditional jump to 0x01fc, if !msg.value label_01F8: // Incoming jump from 0x01F7, if not !msg.value // Inputs[1] { @01FB memory[0x00:0x00] } 01F8 60 PUSH1 0x00 01FA 80 DUP1 01FB FD *REVERT // Stack delta = +0 // Outputs[1] { @01FB revert(memory[0x00:0x00]); } // Block terminates label_01FC: // Incoming jump from 0x01F7, if !msg.value // Inputs[1] { @0204 msg.data.length } 01FC 5B JUMPDEST 01FD 50 POP 01FE 61 PUSH2 0x0217 0201 60 PUSH1 0x04 0203 80 DUP1 0204 36 CALLDATASIZE 0205 03 SUB 0206 81 DUP2 0207 01 ADD 0208 90 SWAP1 0209 61 PUSH2 0x0212 020C 91 SWAP2 020D 90 SWAP1 020E 61 PUSH2 0x1920 0211 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01FE stack[-1] = 0x0217 // @020C stack[0] = 0x0212 // @020D stack[2] = 0x04 // @020D stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1920, returns to 0x0212 label_0212: // Incoming return from call to 0x1920 at 0x0211 0212 5B JUMPDEST 0213 61 PUSH2 0x05e0 0216 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05e0 label_0217: // Incoming return from call to 0x0212 at 0x0211 // Inputs[2] // { // @021A memory[0x40:0x60] // @021E stack[-1] // } 0217 5B JUMPDEST 0218 60 PUSH1 0x40 021A 51 MLOAD 021B 61 PUSH2 0x0224 021E 91 SWAP2 021F 90 SWAP1 0220 61 PUSH2 0x1c53 0223 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @021E stack[-1] = 0x0224 // @021F stack[1] = memory[0x40:0x60] // @021F stack[0] = stack[-1] // } // Block ends with call to 0x1c53, returns to 0x0224 label_0224: // Incoming return from call to 0x1C53 at 0x0223 // Inputs[3] // { // @0227 memory[0x40:0x60] // @0229 stack[-1] // @022C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0224 5B JUMPDEST 0225 60 PUSH1 0x40 0227 51 MLOAD 0228 80 DUP1 0229 91 SWAP2 022A 03 SUB 022B 90 SWAP1 022C F3 *RETURN // Stack delta = -1 // Outputs[1] { @022C return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_022D: // Incoming jump from 0x0113, if 0x06fdde03 == stack[-1] // Inputs[1] { @022E msg.value } 022D 5B JUMPDEST 022E 34 CALLVALUE 022F 80 DUP1 0230 15 ISZERO 0231 61 PUSH2 0x0239 0234 57 *JUMPI // Stack delta = +1 // Outputs[1] { @022E stack[0] = msg.value } // Block ends with conditional jump to 0x0239, if !msg.value label_0235: // Incoming jump from 0x0234, if not !msg.value // Inputs[1] { @0238 memory[0x00:0x00] } 0235 60 PUSH1 0x00 0237 80 DUP1 0238 FD *REVERT // Stack delta = +0 // Outputs[1] { @0238 revert(memory[0x00:0x00]); } // Block terminates label_0239: // Incoming jump from 0x0234, if !msg.value 0239 5B JUMPDEST 023A 50 POP 023B 61 PUSH2 0x0242 023E 61 PUSH2 0x08f1 0241 56 *JUMP // Stack delta = +0 // Outputs[1] { @023B stack[-1] = 0x0242 } // Block ends with call to 0x08f1, returns to 0x0242 label_0242: // Incoming return from call to 0x08F1 at 0x0241 // Inputs[2] // { // @0245 memory[0x40:0x60] // @0249 stack[-1] // } 0242 5B JUMPDEST 0243 60 PUSH1 0x40 0245 51 MLOAD 0246 61 PUSH2 0x024f 0249 91 SWAP2 024A 90 SWAP1 024B 61 PUSH2 0x1cbf 024E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0249 stack[-1] = 0x024f // @024A stack[1] = memory[0x40:0x60] // @024A stack[0] = stack[-1] // } // Block ends with call to 0x1cbf, returns to 0x024F label_024F: // Incoming return from call to 0x1CBF at 0x024E // Inputs[3] // { // @0252 memory[0x40:0x60] // @0254 stack[-1] // @0257 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 024F 5B JUMPDEST 0250 60 PUSH1 0x40 0252 51 MLOAD 0253 80 DUP1 0254 91 SWAP2 0255 03 SUB 0256 90 SWAP1 0257 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0257 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0258: // Incoming jump from 0x011E, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0259 msg.value } 0258 5B JUMPDEST 0259 34 CALLVALUE 025A 80 DUP1 025B 15 ISZERO 025C 61 PUSH2 0x0264 025F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0259 stack[0] = msg.value } // Block ends with conditional jump to 0x0264, if !msg.value label_0260: // Incoming jump from 0x025F, if not !msg.value // Inputs[1] { @0263 memory[0x00:0x00] } 0260 60 PUSH1 0x00 0262 80 DUP1 0263 FD *REVERT // Stack delta = +0 // Outputs[1] { @0263 revert(memory[0x00:0x00]); } // Block terminates label_0264: // Incoming jump from 0x025F, if !msg.value // Inputs[1] { @026C msg.data.length } 0264 5B JUMPDEST 0265 50 POP 0266 61 PUSH2 0x027f 0269 60 PUSH1 0x04 026B 80 DUP1 026C 36 CALLDATASIZE 026D 03 SUB 026E 81 DUP2 026F 01 ADD 0270 90 SWAP1 0271 61 PUSH2 0x027a 0274 91 SWAP2 0275 90 SWAP1 0276 61 PUSH2 0x1a0d 0279 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0266 stack[-1] = 0x027f // @0274 stack[0] = 0x027a // @0275 stack[2] = 0x04 // @0275 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1a0d, returns to 0x027A label_027A: // Incoming return from call to 0x1A0D at 0x0279 027A 5B JUMPDEST 027B 61 PUSH2 0x097f 027E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x097f label_027F: // Incoming return from call to 0x027A at 0x0279 // Inputs[2] // { // @0282 memory[0x40:0x60] // @0286 stack[-1] // } 027F 5B JUMPDEST 0280 60 PUSH1 0x40 0282 51 MLOAD 0283 61 PUSH2 0x028c 0286 91 SWAP2 0287 90 SWAP1 0288 61 PUSH2 0x1c6e 028B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0286 stack[-1] = 0x028c // @0287 stack[1] = memory[0x40:0x60] // @0287 stack[0] = stack[-1] // } // Block ends with call to 0x1c6e, returns to 0x028C label_028C: // Incoming return from call to 0x1C6E at 0x028B // Inputs[3] // { // @028F memory[0x40:0x60] // @0291 stack[-1] // @0294 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 028C 5B JUMPDEST 028D 60 PUSH1 0x40 028F 51 MLOAD 0290 80 DUP1 0291 91 SWAP2 0292 03 SUB 0293 90 SWAP1 0294 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0294 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0295: // Incoming jump from 0x0129, if 0x18160ddd == stack[-1] // Inputs[1] { @0296 msg.value } 0295 5B JUMPDEST 0296 34 CALLVALUE 0297 80 DUP1 0298 15 ISZERO 0299 61 PUSH2 0x02a1 029C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0296 stack[0] = msg.value } // Block ends with conditional jump to 0x02a1, if !msg.value label_029D: // Incoming jump from 0x029C, if not !msg.value // Inputs[1] { @02A0 memory[0x00:0x00] } 029D 60 PUSH1 0x00 029F 80 DUP1 02A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A0 revert(memory[0x00:0x00]); } // Block terminates label_02A1: // Incoming jump from 0x029C, if !msg.value 02A1 5B JUMPDEST 02A2 50 POP 02A3 61 PUSH2 0x02aa 02A6 61 PUSH2 0x099d 02A9 56 *JUMP // Stack delta = +0 // Outputs[1] { @02A3 stack[-1] = 0x02aa } // Block ends with call to 0x099d, returns to 0x02AA label_02AA: // Incoming return from call to 0x099D at 0x02A9 // Inputs[2] // { // @02AD memory[0x40:0x60] // @02B1 stack[-1] // } 02AA 5B JUMPDEST 02AB 60 PUSH1 0x40 02AD 51 MLOAD 02AE 61 PUSH2 0x02b7 02B1 91 SWAP2 02B2 90 SWAP1 02B3 61 PUSH2 0x1e01 02B6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02B1 stack[-1] = 0x02b7 // @02B2 stack[1] = memory[0x40:0x60] // @02B2 stack[0] = stack[-1] // } // Block ends with call to 0x1e01, returns to 0x02B7 label_02B7: // Incoming return from call to 0x1E01 at 0x02B6 // Inputs[3] // { // @02BA memory[0x40:0x60] // @02BC stack[-1] // @02BF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02B7 5B JUMPDEST 02B8 60 PUSH1 0x40 02BA 51 MLOAD 02BB 80 DUP1 02BC 91 SWAP2 02BD 03 SUB 02BE 90 SWAP1 02BF F3 *RETURN // Stack delta = -1 // Outputs[1] { @02BF return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02C0: // Incoming jump from 0x00C1, if 0x23b872dd == stack[-1] // Inputs[1] { @02C1 msg.value } 02C0 5B JUMPDEST 02C1 34 CALLVALUE 02C2 80 DUP1 02C3 15 ISZERO 02C4 61 PUSH2 0x02cc 02C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C1 stack[0] = msg.value } // Block ends with conditional jump to 0x02cc, if !msg.value label_02C8: // Incoming jump from 0x02C7, if not !msg.value // Inputs[1] { @02CB memory[0x00:0x00] } 02C8 60 PUSH1 0x00 02CA 80 DUP1 02CB FD *REVERT // Stack delta = +0 // Outputs[1] { @02CB revert(memory[0x00:0x00]); } // Block terminates label_02CC: // Incoming jump from 0x02C7, if !msg.value // Inputs[1] { @02D4 msg.data.length } 02CC 5B JUMPDEST 02CD 50 POP 02CE 61 PUSH2 0x02e7 02D1 60 PUSH1 0x04 02D3 80 DUP1 02D4 36 CALLDATASIZE 02D5 03 SUB 02D6 81 DUP2 02D7 01 ADD 02D8 90 SWAP1 02D9 61 PUSH2 0x02e2 02DC 91 SWAP2 02DD 90 SWAP1 02DE 61 PUSH2 0x19ba 02E1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02CE stack[-1] = 0x02e7 // @02DC stack[0] = 0x02e2 // @02DD stack[2] = 0x04 // @02DD stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x19ba, returns to 0x02E2 label_02E2: // Incoming return from call to 0x19BA at 0x02E1 02E2 5B JUMPDEST 02E3 61 PUSH2 0x09be 02E6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09be label_02E7: // Incoming return from call to 0x02E2 at 0x02E1 // Inputs[2] // { // @02EA memory[0x40:0x60] // @02EE stack[-1] // } 02E7 5B JUMPDEST 02E8 60 PUSH1 0x40 02EA 51 MLOAD 02EB 61 PUSH2 0x02f4 02EE 91 SWAP2 02EF 90 SWAP1 02F0 61 PUSH2 0x1c6e 02F3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02EE stack[-1] = 0x02f4 // @02EF stack[1] = memory[0x40:0x60] // @02EF stack[0] = stack[-1] // } // Block ends with call to 0x1c6e, returns to 0x02F4 label_02F4: // Incoming return from call to 0x1C6E at 0x02F3 // Inputs[3] // { // @02F7 memory[0x40:0x60] // @02F9 stack[-1] // @02FC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02F4 5B JUMPDEST 02F5 60 PUSH1 0x40 02F7 51 MLOAD 02F8 80 DUP1 02F9 91 SWAP2 02FA 03 SUB 02FB 90 SWAP1 02FC F3 *RETURN // Stack delta = -1 // Outputs[1] { @02FC return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02FD: // Incoming jump from 0x00CC, if 0x313ce567 == stack[-1] // Inputs[1] { @02FE msg.value } 02FD 5B JUMPDEST 02FE 34 CALLVALUE 02FF 80 DUP1 0300 15 ISZERO 0301 61 PUSH2 0x0309 0304 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02FE stack[0] = msg.value } // Block ends with conditional jump to 0x0309, if !msg.value label_0305: // Incoming jump from 0x0304, if not !msg.value // Inputs[1] { @0308 memory[0x00:0x00] } 0305 60 PUSH1 0x00 0307 80 DUP1 0308 FD *REVERT // Stack delta = +0 // Outputs[1] { @0308 revert(memory[0x00:0x00]); } // Block terminates label_0309: // Incoming jump from 0x0304, if !msg.value 0309 5B JUMPDEST 030A 50 POP 030B 61 PUSH2 0x0312 030E 61 PUSH2 0x0abf 0311 56 *JUMP // Stack delta = +0 // Outputs[1] { @030B stack[-1] = 0x0312 } // Block ends with call to 0x0abf, returns to 0x0312 label_0312: // Incoming return from call to 0x0ABF at 0x0311 // Inputs[2] // { // @0315 memory[0x40:0x60] // @0319 stack[-1] // } 0312 5B JUMPDEST 0313 60 PUSH1 0x40 0315 51 MLOAD 0316 61 PUSH2 0x031f 0319 91 SWAP2 031A 90 SWAP1 031B 61 PUSH2 0x1e1c 031E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0319 stack[-1] = 0x031f // @031A stack[1] = memory[0x40:0x60] // @031A stack[0] = stack[-1] // } // Block ends with call to 0x1e1c, returns to 0x031F label_031F: // Incoming return from call to 0x1E1C at 0x031E // Inputs[3] // { // @0322 memory[0x40:0x60] // @0324 stack[-1] // @0327 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 031F 5B JUMPDEST 0320 60 PUSH1 0x40 0322 51 MLOAD 0323 80 DUP1 0324 91 SWAP2 0325 03 SUB 0326 90 SWAP1 0327 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0327 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0328: // Incoming jump from 0x00D7, if 0x39509351 == stack[-1] // Inputs[1] { @0329 msg.value } 0328 5B JUMPDEST 0329 34 CALLVALUE 032A 80 DUP1 032B 15 ISZERO 032C 61 PUSH2 0x0334 032F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0329 stack[0] = msg.value } // Block ends with conditional jump to 0x0334, if !msg.value label_0330: // Incoming jump from 0x032F, if not !msg.value // Inputs[1] { @0333 memory[0x00:0x00] } 0330 60 PUSH1 0x00 0332 80 DUP1 0333 FD *REVERT // Stack delta = +0 // Outputs[1] { @0333 revert(memory[0x00:0x00]); } // Block terminates label_0334: // Incoming jump from 0x032F, if !msg.value // Inputs[1] { @033C msg.data.length } 0334 5B JUMPDEST 0335 50 POP 0336 61 PUSH2 0x034f 0339 60 PUSH1 0x04 033B 80 DUP1 033C 36 CALLDATASIZE 033D 03 SUB 033E 81 DUP2 033F 01 ADD 0340 90 SWAP1 0341 61 PUSH2 0x034a 0344 91 SWAP2 0345 90 SWAP1 0346 61 PUSH2 0x1a0d 0349 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0336 stack[-1] = 0x034f // @0344 stack[0] = 0x034a // @0345 stack[2] = 0x04 // @0345 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1a0d, returns to 0x034A label_034A: // Incoming return from call to 0x1A0D at 0x0349 034A 5B JUMPDEST 034B 61 PUSH2 0x0ac4 034E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ac4 label_034F: // Incoming return from call to 0x034A at 0x0349 // Inputs[2] // { // @0352 memory[0x40:0x60] // @0356 stack[-1] // } 034F 5B JUMPDEST 0350 60 PUSH1 0x40 0352 51 MLOAD 0353 61 PUSH2 0x035c 0356 91 SWAP2 0357 90 SWAP1 0358 61 PUSH2 0x1c6e 035B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0356 stack[-1] = 0x035c // @0357 stack[1] = memory[0x40:0x60] // @0357 stack[0] = stack[-1] // } // Block ends with call to 0x1c6e, returns to 0x035C label_035C: // Incoming return from call to 0x1C6E at 0x035B // Inputs[3] // { // @035F memory[0x40:0x60] // @0361 stack[-1] // @0364 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 035C 5B JUMPDEST 035D 60 PUSH1 0x40 035F 51 MLOAD 0360 80 DUP1 0361 91 SWAP2 0362 03 SUB 0363 90 SWAP1 0364 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0364 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0365: // Incoming jump from 0x00E2, if 0x49bd5a5e == stack[-1] // Inputs[1] { @0366 msg.value } 0365 5B JUMPDEST 0366 34 CALLVALUE 0367 80 DUP1 0368 15 ISZERO 0369 61 PUSH2 0x0371 036C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0366 stack[0] = msg.value } // Block ends with conditional jump to 0x0371, if !msg.value label_036D: // Incoming jump from 0x036C, if not !msg.value // Inputs[1] { @0370 memory[0x00:0x00] } 036D 60 PUSH1 0x00 036F 80 DUP1 0370 FD *REVERT // Stack delta = +0 // Outputs[1] { @0370 revert(memory[0x00:0x00]); } // Block terminates label_0371: // Incoming jump from 0x036C, if !msg.value 0371 5B JUMPDEST 0372 50 POP 0373 61 PUSH2 0x037a 0376 61 PUSH2 0x0b70 0379 56 *JUMP // Stack delta = +0 // Outputs[1] { @0373 stack[-1] = 0x037a } // Block ends with call to 0x0b70, returns to 0x037A label_037A: // Incoming return from call to 0x0B70 at 0x0379 // Inputs[2] // { // @037D memory[0x40:0x60] // @0381 stack[-1] // } 037A 5B JUMPDEST 037B 60 PUSH1 0x40 037D 51 MLOAD 037E 61 PUSH2 0x0387 0381 91 SWAP2 0382 90 SWAP1 0383 61 PUSH2 0x1c53 0386 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0381 stack[-1] = 0x0387 // @0382 stack[1] = memory[0x40:0x60] // @0382 stack[0] = stack[-1] // } // Block ends with call to 0x1c53, returns to 0x0387 label_0387: // Incoming return from call to 0x1C53 at 0x0386 // Inputs[3] // { // @038A memory[0x40:0x60] // @038C stack[-1] // @038F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0387 5B JUMPDEST 0388 60 PUSH1 0x40 038A 51 MLOAD 038B 80 DUP1 038C 91 SWAP2 038D 03 SUB 038E 90 SWAP1 038F F3 *RETURN // Stack delta = -1 // Outputs[1] { @038F return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0390: // Incoming jump from 0x00ED, if 0x70a08231 == stack[-1] // Inputs[1] { @0391 msg.value } 0390 5B JUMPDEST 0391 34 CALLVALUE 0392 80 DUP1 0393 15 ISZERO 0394 61 PUSH2 0x039c 0397 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0391 stack[0] = msg.value } // Block ends with conditional jump to 0x039c, if !msg.value label_0398: // Incoming jump from 0x0397, if not !msg.value // Inputs[1] { @039B memory[0x00:0x00] } 0398 60 PUSH1 0x00 039A 80 DUP1 039B FD *REVERT // Stack delta = +0 // Outputs[1] { @039B revert(memory[0x00:0x00]); } // Block terminates label_039C: // Incoming jump from 0x0397, if !msg.value // Inputs[1] { @03A4 msg.data.length } 039C 5B JUMPDEST 039D 50 POP 039E 61 PUSH2 0x03b7 03A1 60 PUSH1 0x04 03A3 80 DUP1 03A4 36 CALLDATASIZE 03A5 03 SUB 03A6 81 DUP2 03A7 01 ADD 03A8 90 SWAP1 03A9 61 PUSH2 0x03b2 03AC 91 SWAP2 03AD 90 SWAP1 03AE 61 PUSH2 0x1920 03B1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @039E stack[-1] = 0x03b7 // @03AC stack[0] = 0x03b2 // @03AD stack[2] = 0x04 // @03AD stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1920, returns to 0x03B2 label_03B2: // Incoming return from call to 0x1920 at 0x03B1 03B2 5B JUMPDEST 03B3 61 PUSH2 0x0b94 03B6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b94 label_03B7: // Incoming return from call to 0x03B2 at 0x03B1 // Inputs[2] // { // @03BA memory[0x40:0x60] // @03BE stack[-1] // } 03B7 5B JUMPDEST 03B8 60 PUSH1 0x40 03BA 51 MLOAD 03BB 61 PUSH2 0x03c4 03BE 91 SWAP2 03BF 90 SWAP1 03C0 61 PUSH2 0x1e01 03C3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03BE stack[-1] = 0x03c4 // @03BF stack[1] = memory[0x40:0x60] // @03BF stack[0] = stack[-1] // } // Block ends with call to 0x1e01, returns to 0x03C4 label_03C4: // Incoming return from call to 0x1E01 at 0x03C3 // Inputs[3] // { // @03C7 memory[0x40:0x60] // @03C9 stack[-1] // @03CC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 03C4 5B JUMPDEST 03C5 60 PUSH1 0x40 03C7 51 MLOAD 03C8 80 DUP1 03C9 91 SWAP2 03CA 03 SUB 03CB 90 SWAP1 03CC F3 *RETURN // Stack delta = -1 // Outputs[1] { @03CC return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_03CD: // Incoming jump from 0x007A, if 0x8dd95002 == stack[-1] // Inputs[1] { @03CE msg.value } 03CD 5B JUMPDEST 03CE 34 CALLVALUE 03CF 80 DUP1 03D0 15 ISZERO 03D1 61 PUSH2 0x03d9 03D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CE stack[0] = msg.value } // Block ends with conditional jump to 0x03d9, if !msg.value label_03D5: // Incoming jump from 0x03D4, if not !msg.value // Inputs[1] { @03D8 memory[0x00:0x00] } 03D5 60 PUSH1 0x00 03D7 80 DUP1 03D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D8 revert(memory[0x00:0x00]); } // Block terminates label_03D9: // Incoming jump from 0x03D4, if !msg.value 03D9 5B JUMPDEST 03DA 50 POP 03DB 61 PUSH2 0x03e2 03DE 61 PUSH2 0x0bdd 03E1 56 *JUMP // Stack delta = +0 // Outputs[1] { @03DB stack[-1] = 0x03e2 } // Block ends with call to 0x0bdd, returns to 0x03E2 label_03E2: // Incoming return from call to 0x0BDD at 0x03E1 // Inputs[2] // { // @03E5 memory[0x40:0x60] // @03E9 stack[-1] // } 03E2 5B JUMPDEST 03E3 60 PUSH1 0x40 03E5 51 MLOAD 03E6 61 PUSH2 0x03ef 03E9 91 SWAP2 03EA 90 SWAP1 03EB 61 PUSH2 0x1c53 03EE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03E9 stack[-1] = 0x03ef // @03EA stack[1] = memory[0x40:0x60] // @03EA stack[0] = stack[-1] // } // Block ends with call to 0x1c53, returns to 0x03EF label_03EF: // Incoming return from call to 0x1C53 at 0x03EE // Inputs[3] // { // @03F2 memory[0x40:0x60] // @03F4 stack[-1] // @03F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 03EF 5B JUMPDEST 03F0 60 PUSH1 0x40 03F2 51 MLOAD 03F3 80 DUP1 03F4 91 SWAP2 03F5 03 SUB 03F6 90 SWAP1 03F7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @03F7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_03F8: // Incoming jump from 0x0085, if 0x91cca3db == stack[-1] // Inputs[1] { @03F9 msg.value } 03F8 5B JUMPDEST 03F9 34 CALLVALUE 03FA 80 DUP1 03FB 15 ISZERO 03FC 61 PUSH2 0x0404 03FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0404, if !msg.value label_0400: // Incoming jump from 0x03FF, if not !msg.value // Inputs[1] { @0403 memory[0x00:0x00] } 0400 60 PUSH1 0x00 0402 80 DUP1 0403 FD *REVERT // Stack delta = +0 // Outputs[1] { @0403 revert(memory[0x00:0x00]); } // Block terminates label_0404: // Incoming jump from 0x03FF, if !msg.value 0404 5B JUMPDEST 0405 50 POP 0406 61 PUSH2 0x040d 0409 61 PUSH2 0x0c03 040C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0406 stack[-1] = 0x040d } // Block ends with call to 0x0c03, returns to 0x040D label_040D: // Incoming return from call to 0x0C03 at 0x040C // Inputs[2] // { // @0410 memory[0x40:0x60] // @0414 stack[-1] // } 040D 5B JUMPDEST 040E 60 PUSH1 0x40 0410 51 MLOAD 0411 61 PUSH2 0x041a 0414 91 SWAP2 0415 90 SWAP1 0416 61 PUSH2 0x1c53 0419 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0414 stack[-1] = 0x041a // @0415 stack[1] = memory[0x40:0x60] // @0415 stack[0] = stack[-1] // } // Block ends with call to 0x1c53, returns to 0x041A label_041A: // Incoming return from call to 0x1C53 at 0x0419 // Inputs[3] // { // @041D memory[0x40:0x60] // @041F stack[-1] // @0422 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 041A 5B JUMPDEST 041B 60 PUSH1 0x40 041D 51 MLOAD 041E 80 DUP1 041F 91 SWAP2 0420 03 SUB 0421 90 SWAP1 0422 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0422 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0423: // Incoming jump from 0x0090, if 0x95d89b41 == stack[-1] // Inputs[1] { @0424 msg.value } 0423 5B JUMPDEST 0424 34 CALLVALUE 0425 80 DUP1 0426 15 ISZERO 0427 61 PUSH2 0x042f 042A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0424 stack[0] = msg.value } // Block ends with conditional jump to 0x042f, if !msg.value label_042B: // Incoming jump from 0x042A, if not !msg.value // Inputs[1] { @042E memory[0x00:0x00] } 042B 60 PUSH1 0x00 042D 80 DUP1 042E FD *REVERT // Stack delta = +0 // Outputs[1] { @042E revert(memory[0x00:0x00]); } // Block terminates label_042F: // Incoming jump from 0x042A, if !msg.value 042F 5B JUMPDEST 0430 50 POP 0431 61 PUSH2 0x0438 0434 61 PUSH2 0x0c29 0437 56 *JUMP // Stack delta = +0 // Outputs[1] { @0431 stack[-1] = 0x0438 } // Block ends with call to 0x0c29, returns to 0x0438 label_0438: // Incoming return from call to 0x0C29 at 0x0437 // Inputs[2] // { // @043B memory[0x40:0x60] // @043F stack[-1] // } 0438 5B JUMPDEST 0439 60 PUSH1 0x40 043B 51 MLOAD 043C 61 PUSH2 0x0445 043F 91 SWAP2 0440 90 SWAP1 0441 61 PUSH2 0x1cbf 0444 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @043F stack[-1] = 0x0445 // @0440 stack[1] = memory[0x40:0x60] // @0440 stack[0] = stack[-1] // } // Block ends with call to 0x1cbf, returns to 0x0445 label_0445: // Incoming return from call to 0x1CBF at 0x0444 // Inputs[3] // { // @0448 memory[0x40:0x60] // @044A stack[-1] // @044D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0445 5B JUMPDEST 0446 60 PUSH1 0x40 0448 51 MLOAD 0449 80 DUP1 044A 91 SWAP2 044B 03 SUB 044C 90 SWAP1 044D F3 *RETURN // Stack delta = -1 // Outputs[1] { @044D return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_044E: // Incoming jump from 0x009B, if 0xa457c2d7 == stack[-1] // Inputs[1] { @044F msg.value } 044E 5B JUMPDEST 044F 34 CALLVALUE 0450 80 DUP1 0451 15 ISZERO 0452 61 PUSH2 0x045a 0455 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044F stack[0] = msg.value } // Block ends with conditional jump to 0x045a, if !msg.value label_0456: // Incoming jump from 0x0455, if not !msg.value // Inputs[1] { @0459 memory[0x00:0x00] } 0456 60 PUSH1 0x00 0458 80 DUP1 0459 FD *REVERT // Stack delta = +0 // Outputs[1] { @0459 revert(memory[0x00:0x00]); } // Block terminates label_045A: // Incoming jump from 0x0455, if !msg.value // Inputs[1] { @0462 msg.data.length } 045A 5B JUMPDEST 045B 50 POP 045C 61 PUSH2 0x0475 045F 60 PUSH1 0x04 0461 80 DUP1 0462 36 CALLDATASIZE 0463 03 SUB 0464 81 DUP2 0465 01 ADD 0466 90 SWAP1 0467 61 PUSH2 0x0470 046A 91 SWAP2 046B 90 SWAP1 046C 61 PUSH2 0x1a0d 046F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @045C stack[-1] = 0x0475 // @046A stack[0] = 0x0470 // @046B stack[2] = 0x04 // @046B stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1a0d, returns to 0x0470 label_0470: // Incoming return from call to 0x1A0D at 0x046F 0470 5B JUMPDEST 0471 61 PUSH2 0x0cb7 0474 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cb7 label_0475: // Incoming return from call to 0x0470 at 0x046F // Inputs[2] // { // @0478 memory[0x40:0x60] // @047C stack[-1] // } 0475 5B JUMPDEST 0476 60 PUSH1 0x40 0478 51 MLOAD 0479 61 PUSH2 0x0482 047C 91 SWAP2 047D 90 SWAP1 047E 61 PUSH2 0x1c6e 0481 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @047C stack[-1] = 0x0482 // @047D stack[1] = memory[0x40:0x60] // @047D stack[0] = stack[-1] // } // Block ends with call to 0x1c6e, returns to 0x0482 label_0482: // Incoming return from call to 0x1C6E at 0x0481 // Inputs[3] // { // @0485 memory[0x40:0x60] // @0487 stack[-1] // @048A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0482 5B JUMPDEST 0483 60 PUSH1 0x40 0485 51 MLOAD 0486 80 DUP1 0487 91 SWAP2 0488 03 SUB 0489 90 SWAP1 048A F3 *RETURN // Stack delta = -1 // Outputs[1] { @048A return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_048B: // Incoming jump from 0x00A6, if 0xa9059cbb == stack[-1] // Inputs[1] { @048C msg.value } 048B 5B JUMPDEST 048C 34 CALLVALUE 048D 80 DUP1 048E 15 ISZERO 048F 61 PUSH2 0x0497 0492 57 *JUMPI // Stack delta = +1 // Outputs[1] { @048C stack[0] = msg.value } // Block ends with conditional jump to 0x0497, if !msg.value label_0493: // Incoming jump from 0x0492, if not !msg.value // Inputs[1] { @0496 memory[0x00:0x00] } 0493 60 PUSH1 0x00 0495 80 DUP1 0496 FD *REVERT // Stack delta = +0 // Outputs[1] { @0496 revert(memory[0x00:0x00]); } // Block terminates label_0497: // Incoming jump from 0x0492, if !msg.value // Inputs[1] { @049F msg.data.length } 0497 5B JUMPDEST 0498 50 POP 0499 61 PUSH2 0x04b2 049C 60 PUSH1 0x04 049E 80 DUP1 049F 36 CALLDATASIZE 04A0 03 SUB 04A1 81 DUP2 04A2 01 ADD 04A3 90 SWAP1 04A4 61 PUSH2 0x04ad 04A7 91 SWAP2 04A8 90 SWAP1 04A9 61 PUSH2 0x1a0d 04AC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0499 stack[-1] = 0x04b2 // @04A7 stack[0] = 0x04ad // @04A8 stack[2] = 0x04 // @04A8 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1a0d, returns to 0x04AD label_04AD: // Incoming return from call to 0x1A0D at 0x04AC 04AD 5B JUMPDEST 04AE 61 PUSH2 0x0dab 04B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dab label_04B2: // Incoming return from call to 0x04AD at 0x04AC // Inputs[2] // { // @04B5 memory[0x40:0x60] // @04B9 stack[-1] // } 04B2 5B JUMPDEST 04B3 60 PUSH1 0x40 04B5 51 MLOAD 04B6 61 PUSH2 0x04bf 04B9 91 SWAP2 04BA 90 SWAP1 04BB 61 PUSH2 0x1c6e 04BE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04B9 stack[-1] = 0x04bf // @04BA stack[1] = memory[0x40:0x60] // @04BA stack[0] = stack[-1] // } // Block ends with call to 0x1c6e, returns to 0x04BF label_04BF: // Incoming return from call to 0x1C6E at 0x04BE // Inputs[3] // { // @04C2 memory[0x40:0x60] // @04C4 stack[-1] // @04C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 04BF 5B JUMPDEST 04C0 60 PUSH1 0x40 04C2 51 MLOAD 04C3 80 DUP1 04C4 91 SWAP2 04C5 03 SUB 04C6 90 SWAP1 04C7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @04C7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_04C8: // Incoming jump from 0x0033, if 0xba6f43e6 == stack[-1] // Inputs[1] { @04C9 msg.value } 04C8 5B JUMPDEST 04C9 34 CALLVALUE 04CA 80 DUP1 04CB 15 ISZERO 04CC 61 PUSH2 0x04d4 04CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C9 stack[0] = msg.value } // Block ends with conditional jump to 0x04d4, if !msg.value label_04D0: // Incoming jump from 0x04CF, if not !msg.value // Inputs[1] { @04D3 memory[0x00:0x00] } 04D0 60 PUSH1 0x00 04D2 80 DUP1 04D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D3 revert(memory[0x00:0x00]); } // Block terminates label_04D4: // Incoming jump from 0x04CF, if !msg.value 04D4 5B JUMPDEST 04D5 50 POP 04D6 61 PUSH2 0x04dd 04D9 61 PUSH2 0x0dc9 04DC 56 *JUMP // Stack delta = +0 // Outputs[1] { @04D6 stack[-1] = 0x04dd } // Block ends with call to 0x0dc9, returns to 0x04DD label_04DD: // Incoming return from call to 0x0DC9 at 0x04DC // Inputs[2] // { // @04E0 memory[0x40:0x60] // @04E4 stack[-1] // } 04DD 5B JUMPDEST 04DE 60 PUSH1 0x40 04E0 51 MLOAD 04E1 61 PUSH2 0x04ea 04E4 91 SWAP2 04E5 90 SWAP1 04E6 61 PUSH2 0x1c53 04E9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04E4 stack[-1] = 0x04ea // @04E5 stack[1] = memory[0x40:0x60] // @04E5 stack[0] = stack[-1] // } // Block ends with call to 0x1c53, returns to 0x04EA label_04EA: // Incoming return from call to 0x1C53 at 0x04E9 // Inputs[3] // { // @04ED memory[0x40:0x60] // @04EF stack[-1] // @04F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 04EA 5B JUMPDEST 04EB 60 PUSH1 0x40 04ED 51 MLOAD 04EE 80 DUP1 04EF 91 SWAP2 04F0 03 SUB 04F1 90 SWAP1 04F2 F3 *RETURN // Stack delta = -1 // Outputs[1] { @04F2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_04F3: // Incoming jump from 0x003E, if 0xcc1d399f == stack[-1] // Inputs[1] { @04F4 msg.value } 04F3 5B JUMPDEST 04F4 34 CALLVALUE 04F5 80 DUP1 04F6 15 ISZERO 04F7 61 PUSH2 0x04ff 04FA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F4 stack[0] = msg.value } // Block ends with conditional jump to 0x04ff, if !msg.value label_04FB: // Incoming jump from 0x04FA, if not !msg.value // Inputs[1] { @04FE memory[0x00:0x00] } 04FB 60 PUSH1 0x00 04FD 80 DUP1 04FE FD *REVERT // Stack delta = +0 // Outputs[1] { @04FE revert(memory[0x00:0x00]); } // Block terminates label_04FF: // Incoming jump from 0x04FA, if !msg.value 04FF 5B JUMPDEST 0500 50 POP 0501 61 PUSH2 0x0508 0504 61 PUSH2 0x0de1 0507 56 *JUMP // Stack delta = +0 // Outputs[1] { @0501 stack[-1] = 0x0508 } // Block ends with call to 0x0de1, returns to 0x0508 label_0508: // Incoming return from call to 0x0DE1 at 0x0507 // Inputs[2] // { // @050B memory[0x40:0x60] // @050F stack[-1] // } 0508 5B JUMPDEST 0509 60 PUSH1 0x40 050B 51 MLOAD 050C 61 PUSH2 0x0515 050F 91 SWAP2 0510 90 SWAP1 0511 61 PUSH2 0x1ca4 0514 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @050F stack[-1] = 0x0515 // @0510 stack[1] = memory[0x40:0x60] // @0510 stack[0] = stack[-1] // } // Block ends with call to 0x1ca4, returns to 0x0515 label_0515: // Incoming return from call to 0x1CA4 at 0x0514 // Inputs[3] // { // @0518 memory[0x40:0x60] // @051A stack[-1] // @051D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0515 5B JUMPDEST 0516 60 PUSH1 0x40 0518 51 MLOAD 0519 80 DUP1 051A 91 SWAP2 051B 03 SUB 051C 90 SWAP1 051D F3 *RETURN // Stack delta = -1 // Outputs[1] { @051D return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_051E: // Incoming jump from 0x0049, if 0xd8181949 == 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 0x0e07 0532 56 *JUMP // Stack delta = +0 // Outputs[1] { @052C stack[-1] = 0x0533 } // Block ends with call to 0x0e07, returns to 0x0533 label_0533: // Incoming return from call to 0x0E07 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 0x1c89 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 0x1c89, returns to 0x0540 label_0540: // Incoming return from call to 0x1C89 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 jump from 0x0054, if 0xdd62ed3e == stack[-1] // Inputs[1] { @054A msg.value } 0549 5B JUMPDEST 054A 34 CALLVALUE 054B 80 DUP1 054C 15 ISZERO 054D 61 PUSH2 0x0555 0550 57 *JUMPI // Stack delta = +1 // Outputs[1] { @054A stack[0] = msg.value } // Block ends with conditional jump to 0x0555, if !msg.value label_0551: // Incoming jump from 0x0550, if not !msg.value // Inputs[1] { @0554 memory[0x00:0x00] } 0551 60 PUSH1 0x00 0553 80 DUP1 0554 FD *REVERT // Stack delta = +0 // Outputs[1] { @0554 revert(memory[0x00:0x00]); } // Block terminates label_0555: // Incoming jump from 0x0550, if !msg.value // Inputs[1] { @055D msg.data.length } 0555 5B JUMPDEST 0556 50 POP 0557 61 PUSH2 0x0570 055A 60 PUSH1 0x04 055C 80 DUP1 055D 36 CALLDATASIZE 055E 03 SUB 055F 81 DUP2 0560 01 ADD 0561 90 SWAP1 0562 61 PUSH2 0x056b 0565 91 SWAP2 0566 90 SWAP1 0567 61 PUSH2 0x197a 056A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0557 stack[-1] = 0x0570 // @0565 stack[0] = 0x056b // @0566 stack[2] = 0x04 // @0566 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x197a, returns to 0x056B label_056B: // Incoming return from call to 0x197A at 0x056A 056B 5B JUMPDEST 056C 61 PUSH2 0x0e2b 056F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e2b label_0570: // Incoming return from call to 0x056B at 0x056A // Inputs[2] // { // @0573 memory[0x40:0x60] // @0577 stack[-1] // } 0570 5B JUMPDEST 0571 60 PUSH1 0x40 0573 51 MLOAD 0574 61 PUSH2 0x057d 0577 91 SWAP2 0578 90 SWAP1 0579 61 PUSH2 0x1e01 057C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0577 stack[-1] = 0x057d // @0578 stack[1] = memory[0x40:0x60] // @0578 stack[0] = stack[-1] // } // Block ends with call to 0x1e01, returns to 0x057D label_057D: // Incoming return from call to 0x1E01 at 0x057C // Inputs[3] // { // @0580 memory[0x40:0x60] // @0582 stack[-1] // @0585 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 057D 5B JUMPDEST 057E 60 PUSH1 0x40 0580 51 MLOAD 0581 80 DUP1 0582 91 SWAP2 0583 03 SUB 0584 90 SWAP1 0585 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0585 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0586: // Incoming jump from 0x005F, if 0xeb325cc7 == stack[-1] // Inputs[1] { @0587 msg.value } 0586 5B JUMPDEST 0587 34 CALLVALUE 0588 80 DUP1 0589 15 ISZERO 058A 61 PUSH2 0x0592 058D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0587 stack[0] = msg.value } // Block ends with conditional jump to 0x0592, if !msg.value label_058E: // Incoming jump from 0x058D, if not !msg.value // Inputs[1] { @0591 memory[0x00:0x00] } 058E 60 PUSH1 0x00 0590 80 DUP1 0591 FD *REVERT // Stack delta = +0 // Outputs[1] { @0591 revert(memory[0x00:0x00]); } // Block terminates label_0592: // Incoming jump from 0x058D, if !msg.value 0592 5B JUMPDEST 0593 50 POP 0594 61 PUSH2 0x059b 0597 61 PUSH2 0x0eb2 059A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0594 stack[-1] = 0x059b } // Block ends with unconditional jump to 0x0eb2 059B 5B JUMPDEST 059C 00 *STOP label_059D: // Incoming jump from 0x006A, if 0xf1493490 == stack[-1] // Inputs[1] { @059E msg.value } 059D 5B JUMPDEST 059E 34 CALLVALUE 059F 80 DUP1 05A0 15 ISZERO 05A1 61 PUSH2 0x05a9 05A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @059E stack[0] = msg.value } // Block ends with conditional jump to 0x05a9, if !msg.value label_05A5: // Incoming jump from 0x05A4, if not !msg.value // Inputs[1] { @05A8 memory[0x00:0x00] } 05A5 60 PUSH1 0x00 05A7 80 DUP1 05A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @05A8 revert(memory[0x00:0x00]); } // Block terminates label_05A9: // Incoming jump from 0x05A4, if !msg.value // Inputs[1] { @05B1 msg.data.length } 05A9 5B JUMPDEST 05AA 50 POP 05AB 61 PUSH2 0x05c4 05AE 60 PUSH1 0x04 05B0 80 DUP1 05B1 36 CALLDATASIZE 05B2 03 SUB 05B3 81 DUP2 05B4 01 ADD 05B5 90 SWAP1 05B6 61 PUSH2 0x05bf 05B9 91 SWAP2 05BA 90 SWAP1 05BB 61 PUSH2 0x1920 05BE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05AB stack[-1] = 0x05c4 // @05B9 stack[0] = 0x05bf // @05BA stack[2] = 0x04 // @05BA stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x1920, returns to 0x05BF label_05BF: // Incoming return from call to 0x1920 at 0x05BE 05BF 5B JUMPDEST 05C0 61 PUSH2 0x0f7b 05C3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f7b label_05C4: // Incoming return from call to 0x05BF at 0x05BE // Inputs[2] // { // @05C7 memory[0x40:0x60] // @05CB stack[-1] // } 05C4 5B JUMPDEST 05C5 60 PUSH1 0x40 05C7 51 MLOAD 05C8 61 PUSH2 0x05d1 05CB 91 SWAP2 05CC 90 SWAP1 05CD 61 PUSH2 0x1c53 05D0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05CB stack[-1] = 0x05d1 // @05CC stack[1] = memory[0x40:0x60] // @05CC stack[0] = stack[-1] // } // Block ends with call to 0x1c53, returns to 0x05D1 label_05D1: // Incoming return from call to 0x1C53 at 0x05D0 // Inputs[3] // { // @05D4 memory[0x40:0x60] // @05D6 stack[-1] // @05D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 05D1 5B JUMPDEST 05D2 60 PUSH1 0x40 05D4 51 MLOAD 05D5 80 DUP1 05D6 91 SWAP2 05D7 03 SUB 05D8 90 SWAP1 05D9 F3 *RETURN // Stack delta = -1 // Outputs[1] { @05D9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_05DA: // Incoming call from 0x01D9, returns to 0x01DA // Inputs[1] { @05DE stack[-1] } 05DA 5B JUMPDEST 05DB 61 PUSH2 0xdead 05DE 81 DUP2 05DF 56 *JUMP // Stack delta = +1 // Outputs[1] { @05DB stack[0] = 0xdead } // Block ends with unconditional jump to stack[-1] label_05E0: // Incoming jump from 0x0216 // Inputs[1] { @05FF storage[0x01] } 05E0 5B JUMPDEST 05E1 60 PUSH1 0x00 05E3 80 DUP1 05E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05F9 16 AND 05FA 60 PUSH1 0x01 05FC 60 PUSH1 0x00 05FE 90 SWAP1 05FF 54 SLOAD 0600 90 SWAP1 0601 61 PUSH2 0x0100 0604 0A EXP 0605 90 SWAP1 0606 04 DIV 0607 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 061C 16 AND 061D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0632 16 AND 0633 14 EQ 0634 80 DUP1 0635 15 ISZERO 0636 61 PUSH2 0x068c 0639 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @05E1 stack[0] = 0x00 // @0633 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // } // Block ends with conditional jump to 0x068c, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_063A: // Incoming jump from 0x0639, if not !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0656 storage[0x00] } 063A 50 POP 063B 60 PUSH1 0x00 063D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0652 16 AND 0653 60 PUSH1 0x00 0655 80 DUP1 0656 54 SLOAD 0657 90 SWAP1 0658 61 PUSH2 0x0100 065B 0A EXP 065C 90 SWAP1 065D 04 DIV 065E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0673 16 AND 0674 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0689 16 AND 068A 14 EQ 068B 15 ISZERO 068C 5B JUMPDEST 068D 61 PUSH2 0x0695 0690 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0695, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0691: // Incoming jump from 0x0690, if not stack[-1] // Incoming jump from 0x0690, if not !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0694 memory[0x00:0x00] } 0691 60 PUSH1 0x00 0693 80 DUP1 0694 FD *REVERT // Stack delta = +0 // Outputs[1] { @0694 revert(memory[0x00:0x00]); } // Block terminates label_0695: // Incoming jump from 0x0690, if stack[-1] // Incoming jump from 0x0690, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[12] // { // @069D stack[-2] // @06D7 memory[0x00:0x40] // @0728 memory[0x00:0x40] // @078E memory[0x00:0x40] // @07CB memory[0x00:0x40] // @07DC storage[0x03] // @0833 memory[0x00:0x40] // @0884 memory[0x00:0x40] // @0893 storage[0x01] // @08CD storage[0x00] // @08EB stack[-1] // @08ED stack[-3] // } 0695 5B JUMPDEST 0696 60 PUSH1 0x00 0698 19 NOT 0699 60 PUSH1 0x05 069B 60 PUSH1 0x00 069D 84 DUP5 069E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06B3 16 AND 06B4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06C9 16 AND 06CA 81 DUP2 06CB 52 MSTORE 06CC 60 PUSH1 0x20 06CE 01 ADD 06CF 90 SWAP1 06D0 81 DUP2 06D1 52 MSTORE 06D2 60 PUSH1 0x20 06D4 01 ADD 06D5 60 PUSH1 0x00 06D7 20 SHA3 06D8 60 PUSH1 0x00 06DA 73 PUSH20 0x7a250d5630b4cf539739df2c5dacb4c659f2488d 06EF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0704 16 AND 0705 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 071A 16 AND 071B 81 DUP2 071C 52 MSTORE 071D 60 PUSH1 0x20 071F 01 ADD 0720 90 SWAP1 0721 81 DUP2 0722 52 MSTORE 0723 60 PUSH1 0x20 0725 01 ADD 0726 60 PUSH1 0x00 0728 20 SHA3 0729 81 DUP2 072A 90 SWAP1 072B 55 SSTORE 072C 50 POP 072D 60 PUSH1 0x00 072F 19 NOT 0730 60 PUSH1 0x05 0732 60 PUSH1 0x00 0734 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000000 0755 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 076A 16 AND 076B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0780 16 AND 0781 81 DUP2 0782 52 MSTORE 0783 60 PUSH1 0x20 0785 01 ADD 0786 90 SWAP1 0787 81 DUP2 0788 52 MSTORE 0789 60 PUSH1 0x20 078B 01 ADD 078C 60 PUSH1 0x00 078E 20 SHA3 078F 60 PUSH1 0x00 0791 84 DUP5 0792 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07A7 16 AND 07A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07BD 16 AND 07BE 81 DUP2 07BF 52 MSTORE 07C0 60 PUSH1 0x20 07C2 01 ADD 07C3 90 SWAP1 07C4 81 DUP2 07C5 52 MSTORE 07C6 60 PUSH1 0x20 07C8 01 ADD 07C9 60 PUSH1 0x00 07CB 20 SHA3 07CC 81 DUP2 07CD 90 SWAP1 07CE 55 SSTORE 07CF 50 POP 07D0 60 PUSH1 0x00 07D2 19 NOT 07D3 60 PUSH1 0x05 07D5 60 PUSH1 0x00 07D7 60 PUSH1 0x03 07D9 60 PUSH1 0x00 07DB 90 SWAP1 07DC 54 SLOAD 07DD 90 SWAP1 07DE 61 PUSH2 0x0100 07E1 0A EXP 07E2 90 SWAP1 07E3 04 DIV 07E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07F9 16 AND 07FA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 080F 16 AND 0810 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0825 16 AND 0826 81 DUP2 0827 52 MSTORE 0828 60 PUSH1 0x20 082A 01 ADD 082B 90 SWAP1 082C 81 DUP2 082D 52 MSTORE 082E 60 PUSH1 0x20 0830 01 ADD 0831 60 PUSH1 0x00 0833 20 SHA3 0834 60 PUSH1 0x00 0836 73 PUSH20 0x7a250d5630b4cf539739df2c5dacb4c659f2488d 084B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0860 16 AND 0861 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0876 16 AND 0877 81 DUP2 0878 52 MSTORE 0879 60 PUSH1 0x20 087B 01 ADD 087C 90 SWAP1 087D 81 DUP2 087E 52 MSTORE 087F 60 PUSH1 0x20 0881 01 ADD 0882 60 PUSH1 0x00 0884 20 SHA3 0885 81 DUP2 0886 90 SWAP1 0887 55 SSTORE 0888 50 POP 0889 81 DUP2 088A 60 PUSH1 0x01 088C 60 PUSH1 0x00 088E 61 PUSH2 0x0100 0891 0A EXP 0892 81 DUP2 0893 54 SLOAD 0894 81 DUP2 0895 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08AA 02 MUL 08AB 19 NOT 08AC 16 AND 08AD 90 SWAP1 08AE 83 DUP4 08AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08C4 16 AND 08C5 02 MUL 08C6 17 OR 08C7 90 SWAP1 08C8 55 SSTORE 08C9 50 POP 08CA 60 PUSH1 0x00 08CC 80 DUP1 08CD 54 SLOAD 08CE 90 SWAP1 08CF 61 PUSH2 0x0100 08D2 0A EXP 08D3 90 SWAP1 08D4 04 DIV 08D5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08EA 16 AND 08EB 90 SWAP1 08EC 50 POP 08ED 91 SWAP2 08EE 90 SWAP1 08EF 50 POP 08F0 56 *JUMP // Stack delta = -2 // Outputs[17] // { // @06CB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @06D1 memory[0x20:0x40] = 0x05 // @071C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0x7a250d5630b4cf539739df2c5dacb4c659f2488d // @0722 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @072B storage[keccak256(memory[0x00:0x40])] = ~0x00 // @0782 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0x0000000000000000000000000000000000000000000000000000000000000000 // @0788 memory[0x20:0x40] = 0x05 // @07BF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @07C5 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @07CE storage[keccak256(memory[0x00:0x40])] = ~0x00 // @0827 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00 // @082D memory[0x20:0x40] = 0x05 // @0878 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0x7a250d5630b4cf539739df2c5dacb4c659f2488d // @087E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0887 storage[keccak256(memory[0x00:0x40])] = ~0x00 // @08C8 storage[0x01] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x01]) // @08ED stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_08F1: // Incoming call from 0x0241, returns to 0x0242 // Inputs[1] { @08F5 storage[0x06] } 08F1 5B JUMPDEST 08F2 60 PUSH1 0x06 08F4 80 DUP1 08F5 54 SLOAD 08F6 61 PUSH2 0x08fe 08F9 90 SWAP1 08FA 61 PUSH2 0x2183 08FD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08F2 stack[0] = 0x06 // @08F9 stack[1] = 0x08fe // @08F9 stack[2] = storage[0x06] // } // Block ends with call to 0x2183, returns to 0x08FE label_08FE: // Incoming return from call to 0x2183 at 0x08FD // Inputs[4] // { // @08FF stack[-1] // @090E memory[0x40:0x60] // @0916 stack[-2] // @0921 storage[stack[-2]] // } 08FE 5B JUMPDEST 08FF 80 DUP1 0900 60 PUSH1 0x1f 0902 01 ADD 0903 60 PUSH1 0x20 0905 80 DUP1 0906 91 SWAP2 0907 04 DIV 0908 02 MUL 0909 60 PUSH1 0x20 090B 01 ADD 090C 60 PUSH1 0x40 090E 51 MLOAD 090F 90 SWAP1 0910 81 DUP2 0911 01 ADD 0912 60 PUSH1 0x40 0914 52 MSTORE 0915 80 DUP1 0916 92 SWAP3 0917 91 SWAP2 0918 90 SWAP1 0919 81 DUP2 091A 81 DUP2 091B 52 MSTORE 091C 60 PUSH1 0x20 091E 01 ADD 091F 82 DUP3 0920 80 DUP1 0921 54 SLOAD 0922 61 PUSH2 0x092a 0925 90 SWAP1 0926 61 PUSH2 0x2183 0929 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0914 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0916 stack[-2] = memory[0x40:0x60] // @0917 stack[-1] = stack[-2] // @0918 stack[0] = stack[-1] // @091B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @091E stack[1] = 0x20 + memory[0x40:0x60] // @091F stack[2] = stack[-2] // @0925 stack[4] = storage[stack[-2]] // @0925 stack[3] = 0x092a // } // Block ends with call to 0x2183, returns to 0x092A label_092A: // Incoming return from call to 0x2183 at 0x0929 // Inputs[1] { @092B stack[-1] } 092A 5B JUMPDEST 092B 80 DUP1 092C 15 ISZERO 092D 61 PUSH2 0x0977 0930 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0977, if !stack[-1] label_0931: // Incoming jump from 0x0930, if not !stack[-1] // Inputs[1] { @0931 stack[-1] } 0931 80 DUP1 0932 60 PUSH1 0x1f 0934 10 LT 0935 61 PUSH2 0x094c 0938 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x094c, if 0x1f < stack[-1] label_0939: // Incoming jump from 0x0938, if not 0x1f < stack[-1] // Inputs[4] // { // @093D stack[-2] // @093E storage[stack[-2]] // @0941 stack[-3] // @0943 stack[-1] // } 0939 61 PUSH2 0x0100 093C 80 DUP1 093D 83 DUP4 093E 54 SLOAD 093F 04 DIV 0940 02 MUL 0941 83 DUP4 0942 52 MSTORE 0943 91 SWAP2 0944 60 PUSH1 0x20 0946 01 ADD 0947 91 SWAP2 0948 61 PUSH2 0x0977 094B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0942 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0947 stack[-1] = stack[-1] // @0947 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0977 label_094C: // Incoming jump from 0x0938, if 0x1f < stack[-1] // Inputs[5] // { // @094D stack[-3] // @094E stack[-1] // @0950 stack[-2] // @0958 memory[0x00:0x20] // @095C storage[keccak256(memory[0x00:0x20])] // } 094C 5B JUMPDEST 094D 82 DUP3 094E 01 ADD 094F 91 SWAP2 0950 90 SWAP1 0951 60 PUSH1 0x00 0953 52 MSTORE 0954 60 PUSH1 0x20 0956 60 PUSH1 0x00 0958 20 SHA3 0959 90 SWAP1 095A 5B JUMPDEST 095B 81 DUP2 095C 54 SLOAD 095D 81 DUP2 095E 52 MSTORE 095F 90 SWAP1 0960 60 PUSH1 0x01 0962 01 ADD 0963 90 SWAP1 0964 60 PUSH1 0x20 0966 01 ADD 0967 80 DUP1 0968 83 DUP4 0969 11 GT 096A 61 PUSH2 0x095a 096D 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @094F stack[-3] = stack[-3] + stack[-1] // @0953 memory[0x00:0x20] = stack[-2] // @095E memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0963 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0966 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x095a, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_096E: // Incoming jump from 0x096D, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x096D, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @096E stack[-3] // @096F stack[-1] // } 096E 82 DUP3 096F 90 SWAP1 0970 03 SUB 0971 60 PUSH1 0x1f 0973 16 AND 0974 82 DUP3 0975 01 ADD 0976 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0976 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0976 stack[-1] = stack[-3] // } // Block continues label_0977: // Incoming jump from 0x094B // Incoming jump from 0x0930, if !stack[-1] // Incoming jump from 0x0976 // Inputs[1] { @097D stack[-7] } 0977 5B JUMPDEST 0978 50 POP 0979 50 POP 097A 50 POP 097B 50 POP 097C 50 POP 097D 81 DUP2 097E 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_097F: // Incoming jump from 0x027E 097F 5B JUMPDEST 0980 60 PUSH1 0x00 0982 61 PUSH2 0x0993 0985 61 PUSH2 0x098c 0988 61 PUSH2 0x123e 098B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0980 stack[0] = 0x00 // @0982 stack[1] = 0x0993 // @0985 stack[2] = 0x098c // } // Block ends with call to 0x123e, returns to 0x098C label_098C: // Incoming return from call to 0x123E at 0x098B // Inputs[2] // { // @098D stack[-5] // @098E stack[-4] // } 098C 5B JUMPDEST 098D 84 DUP5 098E 84 DUP5 098F 61 PUSH2 0x1246 0992 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @098D stack[0] = stack[-5] // @098E stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x1246 label_0993: // Incoming return from call to 0x098C at 0x098B // Inputs[3] // { // @0996 stack[-1] // @0998 stack[-4] // @0999 stack[-3] // } 0993 5B JUMPDEST 0994 60 PUSH1 0x01 0996 90 SWAP1 0997 50 POP 0998 92 SWAP3 0999 91 SWAP2 099A 50 POP 099B 50 POP 099C 56 *JUMP // Stack delta = -3 // Outputs[1] { @0998 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_099D: // Incoming call from 0x02A9, returns to 0x02AA 099D 5B JUMPDEST 099E 60 PUSH1 0x09 09A0 60 PUSH1 0x0a 09A2 61 PUSH2 0x09ab 09A5 91 SWAP2 09A6 90 SWAP1 09A7 61 PUSH2 0x1f07 09AA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09A5 stack[0] = 0x09ab // @09A6 stack[1] = 0x09 // @09A6 stack[2] = 0x0a // } // Block ends with call to 0x1f07, returns to 0x09AB label_09AB: // Incoming return from call to 0x1F07 at 0x09AA // Inputs[1] { @09B5 stack[-1] } 09AB 5B JUMPDEST 09AC 64 PUSH5 0x02540be400 09B2 61 PUSH2 0x09bb 09B5 91 SWAP2 09B6 90 SWAP1 09B7 61 PUSH2 0x2025 09BA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09B5 stack[-1] = 0x09bb // @09B6 stack[1] = 0x02540be400 // @09B6 stack[0] = stack[-1] // } // Block ends with call to 0x2025, returns to 0x09BB label_09BB: // Incoming return from call to 0x2025 at 0x09BA // Inputs[1] { @09BC stack[-2] } 09BB 5B JUMPDEST 09BC 81 DUP2 09BD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to stack[-2] label_09BE: // Incoming jump from 0x02E6 // Inputs[3] // { // @09C4 stack[-3] // @09C5 stack[-2] // @09C6 stack[-1] // } 09BE 5B JUMPDEST 09BF 60 PUSH1 0x00 09C1 61 PUSH2 0x09cb 09C4 84 DUP5 09C5 84 DUP5 09C6 84 DUP5 09C7 61 PUSH2 0x1411 09CA 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @09BF stack[0] = 0x00 // @09C1 stack[1] = 0x09cb // @09C4 stack[2] = stack[-3] // @09C5 stack[3] = stack[-2] // @09C6 stack[4] = stack[-1] // } // Block ends with call to 0x1411, returns to 0x09CB label_09CB: // Incoming return from call to 0x1411 at 0x09CA // Inputs[2] // { // @09D2 stack[-4] // @0A0C memory[0x00:0x40] // } 09CB 5B JUMPDEST 09CC 60 PUSH1 0x00 09CE 60 PUSH1 0x05 09D0 60 PUSH1 0x00 09D2 86 DUP7 09D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09E8 16 AND 09E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09FE 16 AND 09FF 81 DUP2 0A00 52 MSTORE 0A01 60 PUSH1 0x20 0A03 01 ADD 0A04 90 SWAP1 0A05 81 DUP2 0A06 52 MSTORE 0A07 60 PUSH1 0x20 0A09 01 ADD 0A0A 60 PUSH1 0x00 0A0C 20 SHA3 0A0D 60 PUSH1 0x00 0A0F 61 PUSH2 0x0a16 0A12 61 PUSH2 0x123e 0A15 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @09CC stack[0] = 0x00 // @0A00 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0A06 memory[0x20:0x40] = 0x05 // @0A0C stack[1] = keccak256(memory[0x00:0x40]) // @0A0D stack[2] = 0x00 // @0A0F stack[3] = 0x0a16 // } // Block ends with call to 0x123e, returns to 0x0A16 label_0A16: // Incoming return from call to 0x123E at 0x0A15 // Inputs[7] // { // @0A2C stack[-1] // @0A43 stack[-2] // @0A48 stack[-3] // @0A50 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @0A51 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @0A52 stack[-4] // @0A54 stack[-6] // } 0A16 5B JUMPDEST 0A17 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A2C 16 AND 0A2D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A42 16 AND 0A43 81 DUP2 0A44 52 MSTORE 0A45 60 PUSH1 0x20 0A47 01 ADD 0A48 90 SWAP1 0A49 81 DUP2 0A4A 52 MSTORE 0A4B 60 PUSH1 0x20 0A4D 01 ADD 0A4E 60 PUSH1 0x00 0A50 20 SHA3 0A51 54 SLOAD 0A52 90 SWAP1 0A53 50 POP 0A54 82 DUP3 0A55 81 DUP2 0A56 10 LT 0A57 15 ISZERO 0A58 61 PUSH2 0x0a96 0A5B 57 *JUMPI // Stack delta = -3 // Outputs[3] // { // @0A44 memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0A4A memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @0A52 stack[-4] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // } // Block ends with conditional jump to 0x0a96, if !(storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] < stack[-6]) label_0A5C: // Incoming jump from 0x0A5B, if not !(storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] < stack[-6]) // Inputs[1] { @0A5E memory[0x40:0x60] } 0A5C 60 PUSH1 0x40 0A5E 51 MLOAD 0A5F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A80 81 DUP2 0A81 52 MSTORE 0A82 60 PUSH1 0x04 0A84 01 ADD 0A85 61 PUSH2 0x0a8d 0A88 90 SWAP1 0A89 61 PUSH2 0x1dc1 0A8C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A81 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A88 stack[0] = 0x0a8d // @0A88 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1dc1, returns to 0x0A8D label_0A8D: // Incoming return from call to 0x1DC1 at 0x0A8C // Inputs[3] // { // @0A90 memory[0x40:0x60] // @0A92 stack[-1] // @0A95 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0A8D 5B JUMPDEST 0A8E 60 PUSH1 0x40 0A90 51 MLOAD 0A91 80 DUP1 0A92 91 SWAP2 0A93 03 SUB 0A94 90 SWAP1 0A95 FD *REVERT // Stack delta = -1 // Outputs[1] { @0A95 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0A96: // Incoming jump from 0x0A5B, if !(storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] < stack[-6]) // Inputs[1] { @0A9A stack[-5] } 0A96 5B JUMPDEST 0A97 61 PUSH2 0x0ab3 0A9A 85 DUP6 0A9B 61 PUSH2 0x0aa2 0A9E 61 PUSH2 0x123e 0AA1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A97 stack[0] = 0x0ab3 // @0A9A stack[1] = stack[-5] // @0A9B stack[2] = 0x0aa2 // } // Block ends with call to 0x123e, returns to 0x0AA2 label_0AA2: // Incoming return from call to 0x123E at 0x0AA1 // Inputs[2] // { // @0AA3 stack[-6] // @0AA4 stack[-4] // } 0AA2 5B JUMPDEST 0AA3 85 DUP6 0AA4 84 DUP5 0AA5 61 PUSH2 0x0aae 0AA8 91 SWAP2 0AA9 90 SWAP1 0AAA 61 PUSH2 0x207f 0AAD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AA8 stack[0] = 0x0aae // @0AA9 stack[1] = stack[-6] // @0AA9 stack[2] = stack[-4] // } // Block ends with call to 0x207f, returns to 0x0AAE label_0AAE: // Incoming return from call to 0x207F at 0x0AAD 0AAE 5B JUMPDEST 0AAF 61 PUSH2 0x1246 0AB2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1246 label_0AB3: // Incoming return from call to 0x0AA2 at 0x0AA1 // Inputs[3] // { // @0AB6 stack[-2] // @0AB9 stack[-6] // @0ABA stack[-5] // } 0AB3 5B JUMPDEST 0AB4 60 PUSH1 0x01 0AB6 91 SWAP2 0AB7 50 POP 0AB8 50 POP 0AB9 93 SWAP4 0ABA 92 SWAP3 0ABB 50 POP 0ABC 50 POP 0ABD 50 POP 0ABE 56 *JUMP // Stack delta = -5 // Outputs[1] { @0AB9 stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_0ABF: // Incoming call from 0x0311, returns to 0x0312 // Inputs[1] { @0AC2 stack[-1] } 0ABF 5B JUMPDEST 0AC0 60 PUSH1 0x09 0AC2 81 DUP2 0AC3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AC0 stack[0] = 0x09 } // Block ends with unconditional jump to stack[-1] label_0AC4: // Incoming jump from 0x034E 0AC4 5B JUMPDEST 0AC5 60 PUSH1 0x00 0AC7 61 PUSH2 0x0b66 0ACA 61 PUSH2 0x0ad1 0ACD 61 PUSH2 0x123e 0AD0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AC5 stack[0] = 0x00 // @0AC7 stack[1] = 0x0b66 // @0ACA stack[2] = 0x0ad1 // } // Block ends with call to 0x123e, returns to 0x0AD1 label_0AD1: // Incoming return from call to 0x123E at 0x0AD0 // Inputs[2] // { // @0AD2 stack[-5] // @0AD3 stack[-4] // } 0AD1 5B JUMPDEST 0AD2 84 DUP5 0AD3 84 DUP5 0AD4 60 PUSH1 0x05 0AD6 60 PUSH1 0x00 0AD8 61 PUSH2 0x0adf 0ADB 61 PUSH2 0x123e 0ADE 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0AD2 stack[0] = stack[-5] // @0AD3 stack[1] = stack[-4] // @0AD4 stack[2] = 0x05 // @0AD6 stack[3] = 0x00 // @0AD8 stack[4] = 0x0adf // } // Block ends with call to 0x123e, returns to 0x0ADF label_0ADF: // Incoming return from call to 0x123E at 0x0ADE // Inputs[8] // { // @0AF5 stack[-1] // @0B0C stack[-2] // @0B11 stack[-3] // @0B19 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @0B1C stack[-10] // @0B56 memory[0x00:0x40] // @0B57 storage[keccak256(memory[0x00:0x40])] // @0B5B stack[-4] // } 0ADF 5B JUMPDEST 0AE0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AF5 16 AND 0AF6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B0B 16 AND 0B0C 81 DUP2 0B0D 52 MSTORE 0B0E 60 PUSH1 0x20 0B10 01 ADD 0B11 90 SWAP1 0B12 81 DUP2 0B13 52 MSTORE 0B14 60 PUSH1 0x20 0B16 01 ADD 0B17 60 PUSH1 0x00 0B19 20 SHA3 0B1A 60 PUSH1 0x00 0B1C 88 DUP9 0B1D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B32 16 AND 0B33 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B48 16 AND 0B49 81 DUP2 0B4A 52 MSTORE 0B4B 60 PUSH1 0x20 0B4D 01 ADD 0B4E 90 SWAP1 0B4F 81 DUP2 0B50 52 MSTORE 0B51 60 PUSH1 0x20 0B53 01 ADD 0B54 60 PUSH1 0x00 0B56 20 SHA3 0B57 54 SLOAD 0B58 61 PUSH2 0x0b61 0B5B 91 SWAP2 0B5C 90 SWAP1 0B5D 61 PUSH2 0x1e5e 0B60 56 *JUMP // Stack delta = -1 // Outputs[7] // { // @0B0D memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0B13 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @0B4A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-10] // @0B50 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @0B5B stack[-4] = 0x0b61 // @0B5C stack[-2] = storage[keccak256(memory[0x00:0x40])] // @0B5C stack[-3] = stack[-4] // } // Block ends with call to 0x1e5e, returns to 0x0B61 label_0B61: // Incoming return from call to 0x1E5E at 0x0B60 0B61 5B JUMPDEST 0B62 61 PUSH2 0x1246 0B65 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1246 label_0B66: // Incoming return from call to 0x0AD1 at 0x0AD0 // Inputs[3] // { // @0B69 stack[-1] // @0B6B stack[-4] // @0B6C stack[-3] // } 0B66 5B JUMPDEST 0B67 60 PUSH1 0x01 0B69 90 SWAP1 0B6A 50 POP 0B6B 92 SWAP3 0B6C 91 SWAP2 0B6D 50 POP 0B6E 50 POP 0B6F 56 *JUMP // Stack delta = -3 // Outputs[1] { @0B6B stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_0B70: // Incoming call from 0x0379, returns to 0x037A // Inputs[1] { @0B92 stack[-1] } 0B70 5B JUMPDEST 0B71 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000000 0B92 81 DUP2 0B93 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B71 stack[0] = 0x0000000000000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-1] label_0B94: // Incoming jump from 0x03B6 // Inputs[4] // { // @0B9B stack[-1] // @0BD5 memory[0x00:0x40] // @0BD6 storage[keccak256(memory[0x00:0x40])] // @0BD9 stack[-2] // } 0B94 5B JUMPDEST 0B95 60 PUSH1 0x00 0B97 60 PUSH1 0x04 0B99 60 PUSH1 0x00 0B9B 83 DUP4 0B9C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BB1 16 AND 0BB2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BC7 16 AND 0BC8 81 DUP2 0BC9 52 MSTORE 0BCA 60 PUSH1 0x20 0BCC 01 ADD 0BCD 90 SWAP1 0BCE 81 DUP2 0BCF 52 MSTORE 0BD0 60 PUSH1 0x20 0BD2 01 ADD 0BD3 60 PUSH1 0x00 0BD5 20 SHA3 0BD6 54 SLOAD 0BD7 90 SWAP1 0BD8 50 POP 0BD9 91 SWAP2 0BDA 90 SWAP1 0BDB 50 POP 0BDC 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0BC9 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0BCF memory[0x20:0x40] = 0x04 // @0BD9 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0BDD: // Incoming call from 0x03E1, returns to 0x03E2 // Inputs[2] // { // @0BE3 storage[0x02] // @0C01 stack[-1] // } 0BDD 5B JUMPDEST 0BDE 60 PUSH1 0x02 0BE0 60 PUSH1 0x00 0BE2 90 SWAP1 0BE3 54 SLOAD 0BE4 90 SWAP1 0BE5 61 PUSH2 0x0100 0BE8 0A EXP 0BE9 90 SWAP1 0BEA 04 DIV 0BEB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C00 16 AND 0C01 81 DUP2 0C02 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C00 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0C03: // Incoming call from 0x040C, returns to 0x040D // Inputs[2] // { // @0C09 storage[0x03] // @0C27 stack[-1] // } 0C03 5B JUMPDEST 0C04 60 PUSH1 0x03 0C06 60 PUSH1 0x00 0C08 90 SWAP1 0C09 54 SLOAD 0C0A 90 SWAP1 0C0B 61 PUSH2 0x0100 0C0E 0A EXP 0C0F 90 SWAP1 0C10 04 DIV 0C11 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C26 16 AND 0C27 81 DUP2 0C28 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C26 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0C29: // Incoming call from 0x0437, returns to 0x0438 // Inputs[1] { @0C2D storage[0x07] } 0C29 5B JUMPDEST 0C2A 60 PUSH1 0x07 0C2C 80 DUP1 0C2D 54 SLOAD 0C2E 61 PUSH2 0x0c36 0C31 90 SWAP1 0C32 61 PUSH2 0x2183 0C35 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C2A stack[0] = 0x07 // @0C31 stack[1] = 0x0c36 // @0C31 stack[2] = storage[0x07] // } // Block ends with call to 0x2183, returns to 0x0C36 label_0C36: // Incoming return from call to 0x2183 at 0x0C35 // Inputs[4] // { // @0C37 stack[-1] // @0C46 memory[0x40:0x60] // @0C4E stack[-2] // @0C59 storage[stack[-2]] // } 0C36 5B JUMPDEST 0C37 80 DUP1 0C38 60 PUSH1 0x1f 0C3A 01 ADD 0C3B 60 PUSH1 0x20 0C3D 80 DUP1 0C3E 91 SWAP2 0C3F 04 DIV 0C40 02 MUL 0C41 60 PUSH1 0x20 0C43 01 ADD 0C44 60 PUSH1 0x40 0C46 51 MLOAD 0C47 90 SWAP1 0C48 81 DUP2 0C49 01 ADD 0C4A 60 PUSH1 0x40 0C4C 52 MSTORE 0C4D 80 DUP1 0C4E 92 SWAP3 0C4F 91 SWAP2 0C50 90 SWAP1 0C51 81 DUP2 0C52 81 DUP2 0C53 52 MSTORE 0C54 60 PUSH1 0x20 0C56 01 ADD 0C57 82 DUP3 0C58 80 DUP1 0C59 54 SLOAD 0C5A 61 PUSH2 0x0c62 0C5D 90 SWAP1 0C5E 61 PUSH2 0x2183 0C61 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0C4C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0C4E stack[-2] = memory[0x40:0x60] // @0C4F stack[-1] = stack[-2] // @0C50 stack[0] = stack[-1] // @0C53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0C56 stack[1] = 0x20 + memory[0x40:0x60] // @0C57 stack[2] = stack[-2] // @0C5D stack[4] = storage[stack[-2]] // @0C5D stack[3] = 0x0c62 // } // Block ends with call to 0x2183, returns to 0x0C62 label_0C62: // Incoming return from call to 0x2183 at 0x0C61 // Inputs[1] { @0C63 stack[-1] } 0C62 5B JUMPDEST 0C63 80 DUP1 0C64 15 ISZERO 0C65 61 PUSH2 0x0caf 0C68 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0caf, if !stack[-1] label_0C69: // Incoming jump from 0x0C68, if not !stack[-1] // Inputs[1] { @0C69 stack[-1] } 0C69 80 DUP1 0C6A 60 PUSH1 0x1f 0C6C 10 LT 0C6D 61 PUSH2 0x0c84 0C70 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c84, if 0x1f < stack[-1] label_0C71: // Incoming jump from 0x0C70, if not 0x1f < stack[-1] // Inputs[4] // { // @0C75 stack[-2] // @0C76 storage[stack[-2]] // @0C79 stack[-3] // @0C7B stack[-1] // } 0C71 61 PUSH2 0x0100 0C74 80 DUP1 0C75 83 DUP4 0C76 54 SLOAD 0C77 04 DIV 0C78 02 MUL 0C79 83 DUP4 0C7A 52 MSTORE 0C7B 91 SWAP2 0C7C 60 PUSH1 0x20 0C7E 01 ADD 0C7F 91 SWAP2 0C80 61 PUSH2 0x0caf 0C83 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0C7A memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0C7F stack[-1] = stack[-1] // @0C7F stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0caf label_0C84: // Incoming jump from 0x0C70, if 0x1f < stack[-1] // Inputs[5] // { // @0C85 stack[-3] // @0C86 stack[-1] // @0C88 stack[-2] // @0C90 memory[0x00:0x20] // @0C94 storage[keccak256(memory[0x00:0x20])] // } 0C84 5B JUMPDEST 0C85 82 DUP3 0C86 01 ADD 0C87 91 SWAP2 0C88 90 SWAP1 0C89 60 PUSH1 0x00 0C8B 52 MSTORE 0C8C 60 PUSH1 0x20 0C8E 60 PUSH1 0x00 0C90 20 SHA3 0C91 90 SWAP1 0C92 5B JUMPDEST 0C93 81 DUP2 0C94 54 SLOAD 0C95 81 DUP2 0C96 52 MSTORE 0C97 90 SWAP1 0C98 60 PUSH1 0x01 0C9A 01 ADD 0C9B 90 SWAP1 0C9C 60 PUSH1 0x20 0C9E 01 ADD 0C9F 80 DUP1 0CA0 83 DUP4 0CA1 11 GT 0CA2 61 PUSH2 0x0c92 0CA5 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0C87 stack[-3] = stack[-3] + stack[-1] // @0C8B memory[0x00:0x20] = stack[-2] // @0C96 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0C9B stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0C9E stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0c92, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0CA6: // Incoming jump from 0x0CA5, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0CA5, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0CA6 stack[-3] // @0CA7 stack[-1] // } 0CA6 82 DUP3 0CA7 90 SWAP1 0CA8 03 SUB 0CA9 60 PUSH1 0x1f 0CAB 16 AND 0CAC 82 DUP3 0CAD 01 ADD 0CAE 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0CAE stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0CAE stack[-1] = stack[-3] // } // Block continues label_0CAF: // Incoming jump from 0x0C68, if !stack[-1] // Incoming jump from 0x0C83 // Incoming jump from 0x0CAE // Inputs[1] { @0CB5 stack[-7] } 0CAF 5B JUMPDEST 0CB0 50 POP 0CB1 50 POP 0CB2 50 POP 0CB3 50 POP 0CB4 50 POP 0CB5 81 DUP2 0CB6 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0CB7: // Incoming jump from 0x0474 0CB7 5B JUMPDEST 0CB8 60 PUSH1 0x00 0CBA 80 DUP1 0CBB 60 PUSH1 0x05 0CBD 60 PUSH1 0x00 0CBF 61 PUSH2 0x0cc6 0CC2 61 PUSH2 0x123e 0CC5 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0CB8 stack[0] = 0x00 // @0CBA stack[1] = 0x00 // @0CBB stack[2] = 0x05 // @0CBD stack[3] = 0x00 // @0CBF stack[4] = 0x0cc6 // } // Block ends with call to 0x123e, returns to 0x0CC6 label_0CC6: // Incoming return from call to 0x123E at 0x0CC5 // Inputs[9] // { // @0CDC stack[-1] // @0CF3 stack[-2] // @0CF8 stack[-3] // @0D00 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @0D03 stack[-7] // @0D3D memory[0x00:0x40] // @0D3E storage[keccak256(memory[0x00:0x40])] // @0D3F stack[-4] // @0D41 stack[-6] // } 0CC6 5B JUMPDEST 0CC7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CDC 16 AND 0CDD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CF2 16 AND 0CF3 81 DUP2 0CF4 52 MSTORE 0CF5 60 PUSH1 0x20 0CF7 01 ADD 0CF8 90 SWAP1 0CF9 81 DUP2 0CFA 52 MSTORE 0CFB 60 PUSH1 0x20 0CFD 01 ADD 0CFE 60 PUSH1 0x00 0D00 20 SHA3 0D01 60 PUSH1 0x00 0D03 85 DUP6 0D04 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D19 16 AND 0D1A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D2F 16 AND 0D30 81 DUP2 0D31 52 MSTORE 0D32 60 PUSH1 0x20 0D34 01 ADD 0D35 90 SWAP1 0D36 81 DUP2 0D37 52 MSTORE 0D38 60 PUSH1 0x20 0D3A 01 ADD 0D3B 60 PUSH1 0x00 0D3D 20 SHA3 0D3E 54 SLOAD 0D3F 90 SWAP1 0D40 50 POP 0D41 82 DUP3 0D42 81 DUP2 0D43 10 LT 0D44 15 ISZERO 0D45 61 PUSH2 0x0d83 0D48 57 *JUMPI // Stack delta = -3 // Outputs[5] // { // @0CF4 memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0CFA memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @0D31 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @0D37 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @0D3F stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0d83, if !(storage[keccak256(memory[0x00:0x40])] < stack[-6]) label_0D49: // Incoming jump from 0x0D48, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-6]) // Inputs[1] { @0D4B memory[0x40:0x60] } 0D49 60 PUSH1 0x40 0D4B 51 MLOAD 0D4C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0D6D 81 DUP2 0D6E 52 MSTORE 0D6F 60 PUSH1 0x04 0D71 01 ADD 0D72 61 PUSH2 0x0d7a 0D75 90 SWAP1 0D76 61 PUSH2 0x1d01 0D79 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D6E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0D75 stack[0] = 0x0d7a // @0D75 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1d01, returns to 0x0D7A label_0D7A: // Incoming return from call to 0x1D01 at 0x0D79 // Inputs[3] // { // @0D7D memory[0x40:0x60] // @0D7F stack[-1] // @0D82 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0D7A 5B JUMPDEST 0D7B 60 PUSH1 0x40 0D7D 51 MLOAD 0D7E 80 DUP1 0D7F 91 SWAP2 0D80 03 SUB 0D81 90 SWAP1 0D82 FD *REVERT // Stack delta = -1 // Outputs[1] { @0D82 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0D83: // Incoming jump from 0x0D48, if !(storage[keccak256(memory[0x00:0x40])] < stack[-6]) 0D83 5B JUMPDEST 0D84 61 PUSH2 0x0da0 0D87 61 PUSH2 0x0d8e 0D8A 61 PUSH2 0x123e 0D8D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D84 stack[0] = 0x0da0 // @0D87 stack[1] = 0x0d8e // } // Block ends with call to 0x123e, returns to 0x0D8E label_0D8E: // Incoming return from call to 0x123E at 0x0D8D // Inputs[3] // { // @0D8F stack[-6] // @0D90 stack[-5] // @0D91 stack[-3] // } 0D8E 5B JUMPDEST 0D8F 85 DUP6 0D90 85 DUP6 0D91 84 DUP5 0D92 61 PUSH2 0x0d9b 0D95 91 SWAP2 0D96 90 SWAP1 0D97 61 PUSH2 0x207f 0D9A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D8F stack[0] = stack[-6] // @0D95 stack[1] = 0x0d9b // @0D96 stack[2] = stack[-5] // @0D96 stack[3] = stack[-3] // } // Block ends with call to 0x207f, returns to 0x0D9B label_0D9B: // Incoming return from call to 0x207F at 0x0D9A 0D9B 5B JUMPDEST 0D9C 61 PUSH2 0x1246 0D9F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1246 label_0DA0: // Incoming return from call to 0x0D8E at 0x0D8D // Inputs[3] // { // @0DA3 stack[-2] // @0DA6 stack[-5] // @0DA7 stack[-4] // } 0DA0 5B JUMPDEST 0DA1 60 PUSH1 0x01 0DA3 91 SWAP2 0DA4 50 POP 0DA5 50 POP 0DA6 92 SWAP3 0DA7 91 SWAP2 0DA8 50 POP 0DA9 50 POP 0DAA 56 *JUMP // Stack delta = -4 // Outputs[1] { @0DA6 stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_0DAB: // Incoming jump from 0x04B1 0DAB 5B JUMPDEST 0DAC 60 PUSH1 0x00 0DAE 61 PUSH2 0x0dbf 0DB1 61 PUSH2 0x0db8 0DB4 61 PUSH2 0x123e 0DB7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DAC stack[0] = 0x00 // @0DAE stack[1] = 0x0dbf // @0DB1 stack[2] = 0x0db8 // } // Block ends with call to 0x123e, returns to 0x0DB8 label_0DB8: // Incoming return from call to 0x123E at 0x0DB7 // Inputs[2] // { // @0DB9 stack[-5] // @0DBA stack[-4] // } 0DB8 5B JUMPDEST 0DB9 84 DUP5 0DBA 84 DUP5 0DBB 61 PUSH2 0x1411 0DBE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DB9 stack[0] = stack[-5] // @0DBA stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x1411 label_0DBF: // Incoming return from call to 0x0DB8 at 0x0DB7 // Inputs[3] // { // @0DC2 stack[-1] // @0DC4 stack[-4] // @0DC5 stack[-3] // } 0DBF 5B JUMPDEST 0DC0 60 PUSH1 0x01 0DC2 90 SWAP1 0DC3 50 POP 0DC4 92 SWAP3 0DC5 91 SWAP2 0DC6 50 POP 0DC7 50 POP 0DC8 56 *JUMP // Stack delta = -3 // Outputs[1] { @0DC4 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_0DC9: // Incoming call from 0x04DC, returns to 0x04DD // Inputs[1] { @0DDF stack[-1] } 0DC9 5B JUMPDEST 0DCA 73 PUSH20 0x7a250d5630b4cf539739df2c5dacb4c659f2488d 0DDF 81 DUP2 0DE0 56 *JUMP // Stack delta = +1 // Outputs[1] { @0DCA stack[0] = 0x7a250d5630b4cf539739df2c5dacb4c659f2488d } // Block ends with unconditional jump to stack[-1] label_0DE1: // Incoming call from 0x0507, returns to 0x0508 // Inputs[2] // { // @0DE7 storage[0x01] // @0E05 stack[-1] // } 0DE1 5B JUMPDEST 0DE2 60 PUSH1 0x01 0DE4 60 PUSH1 0x00 0DE6 90 SWAP1 0DE7 54 SLOAD 0DE8 90 SWAP1 0DE9 61 PUSH2 0x0100 0DEC 0A EXP 0DED 90 SWAP1 0DEE 04 DIV 0DEF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E04 16 AND 0E05 81 DUP2 0E06 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E04 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0E07: // Incoming call from 0x0532, returns to 0x0533 // Inputs[2] // { // @0E0B storage[0x00] // @0E29 stack[-1] // } 0E07 5B JUMPDEST 0E08 60 PUSH1 0x00 0E0A 80 DUP1 0E0B 54 SLOAD 0E0C 90 SWAP1 0E0D 61 PUSH2 0x0100 0E10 0A EXP 0E11 90 SWAP1 0E12 04 DIV 0E13 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E28 16 AND 0E29 81 DUP2 0E2A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E28 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0E2B: // Incoming jump from 0x056F // Inputs[6] // { // @0E32 stack[-2] // @0E6C memory[0x00:0x40] // @0E6F stack[-1] // @0EA9 memory[0x00:0x40] // @0EAA storage[keccak256(memory[0x00:0x40])] // @0EAD stack[-3] // } 0E2B 5B JUMPDEST 0E2C 60 PUSH1 0x00 0E2E 60 PUSH1 0x05 0E30 60 PUSH1 0x00 0E32 84 DUP5 0E33 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E48 16 AND 0E49 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E5E 16 AND 0E5F 81 DUP2 0E60 52 MSTORE 0E61 60 PUSH1 0x20 0E63 01 ADD 0E64 90 SWAP1 0E65 81 DUP2 0E66 52 MSTORE 0E67 60 PUSH1 0x20 0E69 01 ADD 0E6A 60 PUSH1 0x00 0E6C 20 SHA3 0E6D 60 PUSH1 0x00 0E6F 83 DUP4 0E70 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E85 16 AND 0E86 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E9B 16 AND 0E9C 81 DUP2 0E9D 52 MSTORE 0E9E 60 PUSH1 0x20 0EA0 01 ADD 0EA1 90 SWAP1 0EA2 81 DUP2 0EA3 52 MSTORE 0EA4 60 PUSH1 0x20 0EA6 01 ADD 0EA7 60 PUSH1 0x00 0EA9 20 SHA3 0EAA 54 SLOAD 0EAB 90 SWAP1 0EAC 50 POP 0EAD 92 SWAP3 0EAE 91 SWAP2 0EAF 50 POP 0EB0 50 POP 0EB1 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0E60 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0E66 memory[0x20:0x40] = 0x05 // @0E9D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0EA3 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0EAD stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0EB2: // Incoming jump from 0x059A // Inputs[2] // { // @0EB6 storage[0x00] // @0EEA msg.sender // } 0EB2 5B JUMPDEST 0EB3 60 PUSH1 0x00 0EB5 80 DUP1 0EB6 54 SLOAD 0EB7 90 SWAP1 0EB8 61 PUSH2 0x0100 0EBB 0A EXP 0EBC 90 SWAP1 0EBD 04 DIV 0EBE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ED3 16 AND 0ED4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EE9 16 AND 0EEA 33 CALLER 0EEB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F00 16 AND 0F01 14 EQ 0F02 61 PUSH2 0x0f40 0F05 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f40, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 label_0F06: // Incoming jump from 0x0F05, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // Inputs[1] { @0F08 memory[0x40:0x60] } 0F06 60 PUSH1 0x40 0F08 51 MLOAD 0F09 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0F2A 81 DUP2 0F2B 52 MSTORE 0F2C 60 PUSH1 0x04 0F2E 01 ADD 0F2F 61 PUSH2 0x0f37 0F32 90 SWAP1 0F33 61 PUSH2 0x1d41 0F36 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F2B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0F32 stack[0] = 0x0f37 // @0F32 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1d41, returns to 0x0F37 label_0F37: // Incoming return from call to 0x1D41 at 0x0F36 // Inputs[3] // { // @0F3A memory[0x40:0x60] // @0F3C stack[-1] // @0F3F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0F37 5B JUMPDEST 0F38 60 PUSH1 0x40 0F3A 51 MLOAD 0F3B 80 DUP1 0F3C 91 SWAP2 0F3D 03 SUB 0F3E 90 SWAP1 0F3F FD *REVERT // Stack delta = -1 // Outputs[1] { @0F3F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0F40: // Incoming jump from 0x0F05, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // Inputs[1] { @0F46 storage[0x03] } 0F40 5B JUMPDEST 0F41 60 PUSH1 0x03 0F43 60 PUSH1 0x00 0F45 90 SWAP1 0F46 54 SLOAD 0F47 90 SWAP1 0F48 61 PUSH2 0x0100 0F4B 0A EXP 0F4C 90 SWAP1 0F4D 04 DIV 0F4E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F63 16 AND 0F64 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F79 16 AND 0F7A FF *SELFDESTRUCT // Stack delta = +0 // Outputs[1] { @0F7A selfdestruct(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00); } // Block terminates label_0F7B: // Incoming jump from 0x05C3 // Inputs[1] { @0F98 storage[0x00] } 0F7B 5B JUMPDEST 0F7C 60 PUSH1 0x00 0F7E 80 DUP1 0F7F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F94 16 AND 0F95 60 PUSH1 0x00 0F97 80 DUP1 0F98 54 SLOAD 0F99 90 SWAP1 0F9A 61 PUSH2 0x0100 0F9D 0A EXP 0F9E 90 SWAP1 0F9F 04 DIV 0FA0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FB5 16 AND 0FB6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FCB 16 AND 0FCC 14 EQ 0FCD 61 PUSH2 0x0fd5 0FD0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F7C stack[0] = 0x00 } // Block ends with conditional jump to 0x0fd5, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 label_0FD1: // Incoming jump from 0x0FD0, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // Inputs[1] { @0FD4 memory[0x00:0x00] } 0FD1 60 PUSH1 0x00 0FD3 80 DUP1 0FD4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FD4 revert(memory[0x00:0x00]); } // Block terminates label_0FD5: // Incoming jump from 0x0FD0, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // Inputs[9] // { // @0FDD stack[-2] // @1017 memory[0x00:0x40] // @1068 memory[0x00:0x40] // @10CE memory[0x00:0x40] // @110B memory[0x00:0x40] // @1113 address(this) // @1119 address(this) // @1153 memory[0x00:0x40] // @1154 storage[keccak256(memory[0x00:0x40])] // } 0FD5 5B JUMPDEST 0FD6 60 PUSH1 0x00 0FD8 19 NOT 0FD9 60 PUSH1 0x05 0FDB 60 PUSH1 0x00 0FDD 84 DUP5 0FDE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FF3 16 AND 0FF4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1009 16 AND 100A 81 DUP2 100B 52 MSTORE 100C 60 PUSH1 0x20 100E 01 ADD 100F 90 SWAP1 1010 81 DUP2 1011 52 MSTORE 1012 60 PUSH1 0x20 1014 01 ADD 1015 60 PUSH1 0x00 1017 20 SHA3 1018 60 PUSH1 0x00 101A 73 PUSH20 0x7a250d5630b4cf539739df2c5dacb4c659f2488d 102F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1044 16 AND 1045 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 105A 16 AND 105B 81 DUP2 105C 52 MSTORE 105D 60 PUSH1 0x20 105F 01 ADD 1060 90 SWAP1 1061 81 DUP2 1062 52 MSTORE 1063 60 PUSH1 0x20 1065 01 ADD 1066 60 PUSH1 0x00 1068 20 SHA3 1069 81 DUP2 106A 90 SWAP1 106B 55 SSTORE 106C 50 POP 106D 60 PUSH1 0x00 106F 19 NOT 1070 60 PUSH1 0x05 1072 60 PUSH1 0x00 1074 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000000 1095 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10AA 16 AND 10AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10C0 16 AND 10C1 81 DUP2 10C2 52 MSTORE 10C3 60 PUSH1 0x20 10C5 01 ADD 10C6 90 SWAP1 10C7 81 DUP2 10C8 52 MSTORE 10C9 60 PUSH1 0x20 10CB 01 ADD 10CC 60 PUSH1 0x00 10CE 20 SHA3 10CF 60 PUSH1 0x00 10D1 84 DUP5 10D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10E7 16 AND 10E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10FD 16 AND 10FE 81 DUP2 10FF 52 MSTORE 1100 60 PUSH1 0x20 1102 01 ADD 1103 90 SWAP1 1104 81 DUP2 1105 52 MSTORE 1106 60 PUSH1 0x20 1108 01 ADD 1109 60 PUSH1 0x00 110B 20 SHA3 110C 81 DUP2 110D 90 SWAP1 110E 55 SSTORE 110F 50 POP 1110 61 PUSH2 0x1159 1113 30 ADDRESS 1114 83 DUP4 1115 60 PUSH1 0x04 1117 60 PUSH1 0x00 1119 30 ADDRESS 111A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 112F 16 AND 1130 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1145 16 AND 1146 81 DUP2 1147 52 MSTORE 1148 60 PUSH1 0x20 114A 01 ADD 114B 90 SWAP1 114C 81 DUP2 114D 52 MSTORE 114E 60 PUSH1 0x20 1150 01 ADD 1151 60 PUSH1 0x00 1153 20 SHA3 1154 54 SLOAD 1155 61 PUSH2 0x1544 1158 56 *JUMP // Stack delta = +4 // Outputs[16] // { // @100B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1011 memory[0x20:0x40] = 0x05 // @105C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0x7a250d5630b4cf539739df2c5dacb4c659f2488d // @1062 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @106B storage[keccak256(memory[0x00:0x40])] = ~0x00 // @10C2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0x0000000000000000000000000000000000000000000000000000000000000000 // @10C8 memory[0x20:0x40] = 0x05 // @10FF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1105 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @110E storage[keccak256(memory[0x00:0x40])] = ~0x00 // @1110 stack[0] = 0x1159 // @1113 stack[1] = address(this) // @1114 stack[2] = stack[-2] // @1147 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @114D memory[0x20:0x40] = 0x04 // @1154 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1544, returns to 0x1159 label_1159: // Incoming return from call to 0x1544 at 0x1158 // Inputs[8] // { // @115A stack[-2] // @1163 storage[0x00] // @11B7 storage[0x03] // @120E memory[0x40:0x60] // @1211 memory[0x40:0x60] // @1216 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1238 stack[-1] // @123A stack[-3] // } 1159 5B JUMPDEST 115A 81 DUP2 115B 60 PUSH1 0x00 115D 80 DUP1 115E 61 PUSH2 0x0100 1161 0A EXP 1162 81 DUP2 1163 54 SLOAD 1164 81 DUP2 1165 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 117A 02 MUL 117B 19 NOT 117C 16 AND 117D 90 SWAP1 117E 83 DUP4 117F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1194 16 AND 1195 02 MUL 1196 17 OR 1197 90 SWAP1 1198 55 SSTORE 1199 50 POP 119A 60 PUSH1 0x00 119C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11B1 16 AND 11B2 60 PUSH1 0x03 11B4 60 PUSH1 0x00 11B6 90 SWAP1 11B7 54 SLOAD 11B8 90 SWAP1 11B9 61 PUSH2 0x0100 11BC 0A EXP 11BD 90 SWAP1 11BE 04 DIV 11BF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11D4 16 AND 11D5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11EA 16 AND 11EB 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 120C 60 PUSH1 0x40 120E 51 MLOAD 120F 60 PUSH1 0x40 1211 51 MLOAD 1212 80 DUP1 1213 91 SWAP2 1214 03 SUB 1215 90 SWAP1 1216 A3 LOG3 1217 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000000 1238 90 SWAP1 1239 50 POP 123A 91 SWAP2 123B 90 SWAP1 123C 50 POP 123D 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1198 storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00]) // @1216 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x03] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); // @123A stack[-3] = 0x0000000000000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-3] label_123E: // Incoming call from 0x0CC5, returns to 0x0CC6 // Incoming call from 0x0D8D, returns to 0x0D8E // Incoming call from 0x0AA1, returns to 0x0AA2 // Incoming call from 0x0DB7, returns to 0x0DB8 // Incoming call from 0x0ADE, returns to 0x0ADF // Incoming call from 0x0AD0, returns to 0x0AD1 // Incoming call from 0x0A15, returns to 0x0A16 // Incoming call from 0x098B, returns to 0x098C // Inputs[2] // { // @1241 msg.sender // @1244 stack[-1] // } 123E 5B JUMPDEST 123F 60 PUSH1 0x00 1241 33 CALLER 1242 90 SWAP1 1243 50 POP 1244 90 SWAP1 1245 56 *JUMP // Stack delta = +0 // Outputs[1] { @1244 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_1246: // Incoming jump from 0x0992 // Incoming jump from 0x0AB2 // Incoming jump from 0x0B65 // Incoming jump from 0x0D9F // Inputs[1] { @125F stack[-3] } 1246 5B JUMPDEST 1247 60 PUSH1 0x00 1249 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 125E 16 AND 125F 83 DUP4 1260 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1275 16 AND 1276 14 EQ 1277 15 ISZERO 1278 61 PUSH2 0x12b6 127B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12b6, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_127C: // Incoming jump from 0x127B, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @127E memory[0x40:0x60] } 127C 60 PUSH1 0x40 127E 51 MLOAD 127F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 12A0 81 DUP2 12A1 52 MSTORE 12A2 60 PUSH1 0x04 12A4 01 ADD 12A5 61 PUSH2 0x12ad 12A8 90 SWAP1 12A9 61 PUSH2 0x1d81 12AC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @12A8 stack[0] = 0x12ad // @12A8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1d81, returns to 0x12AD label_12AD: // Incoming return from call to 0x1D81 at 0x12AC // Inputs[3] // { // @12B0 memory[0x40:0x60] // @12B2 stack[-1] // @12B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 12AD 5B JUMPDEST 12AE 60 PUSH1 0x40 12B0 51 MLOAD 12B1 80 DUP1 12B2 91 SWAP2 12B3 03 SUB 12B4 90 SWAP1 12B5 FD *REVERT // Stack delta = -1 // Outputs[1] { @12B5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_12B6: // Incoming jump from 0x127B, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @12CF stack[-2] } 12B6 5B JUMPDEST 12B7 60 PUSH1 0x00 12B9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12CE 16 AND 12CF 82 DUP3 12D0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12E5 16 AND 12E6 14 EQ 12E7 15 ISZERO 12E8 61 PUSH2 0x1326 12EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1326, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_12EC: // Incoming jump from 0x12EB, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @12EE memory[0x40:0x60] } 12EC 60 PUSH1 0x40 12EE 51 MLOAD 12EF 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1310 81 DUP2 1311 52 MSTORE 1312 60 PUSH1 0x04 1314 01 ADD 1315 61 PUSH2 0x131d 1318 90 SWAP1 1319 61 PUSH2 0x1d21 131C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1311 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1318 stack[0] = 0x131d // @1318 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1d21, returns to 0x131D label_131D: // Incoming return from call to 0x1D21 at 0x131C // Inputs[3] // { // @1320 memory[0x40:0x60] // @1322 stack[-1] // @1325 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 131D 5B JUMPDEST 131E 60 PUSH1 0x40 1320 51 MLOAD 1321 80 DUP1 1322 91 SWAP2 1323 03 SUB 1324 90 SWAP1 1325 FD *REVERT // Stack delta = -1 // Outputs[1] { @1325 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1326: // Incoming jump from 0x12EB, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @1327 stack[-1] // @132C stack[-3] // @1366 memory[0x00:0x40] // @1369 stack[-2] // @13A3 memory[0x00:0x40] // @13FA memory[0x40:0x60] // } 1326 5B JUMPDEST 1327 80 DUP1 1328 60 PUSH1 0x05 132A 60 PUSH1 0x00 132C 85 DUP6 132D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1342 16 AND 1343 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1358 16 AND 1359 81 DUP2 135A 52 MSTORE 135B 60 PUSH1 0x20 135D 01 ADD 135E 90 SWAP1 135F 81 DUP2 1360 52 MSTORE 1361 60 PUSH1 0x20 1363 01 ADD 1364 60 PUSH1 0x00 1366 20 SHA3 1367 60 PUSH1 0x00 1369 84 DUP5 136A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 137F 16 AND 1380 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1395 16 AND 1396 81 DUP2 1397 52 MSTORE 1398 60 PUSH1 0x20 139A 01 ADD 139B 90 SWAP1 139C 81 DUP2 139D 52 MSTORE 139E 60 PUSH1 0x20 13A0 01 ADD 13A1 60 PUSH1 0x00 13A3 20 SHA3 13A4 81 DUP2 13A5 90 SWAP1 13A6 55 SSTORE 13A7 50 POP 13A8 81 DUP2 13A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13BE 16 AND 13BF 83 DUP4 13C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13D5 16 AND 13D6 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 13F7 83 DUP4 13F8 60 PUSH1 0x40 13FA 51 MLOAD 13FB 61 PUSH2 0x1404 13FE 91 SWAP2 13FF 90 SWAP1 1400 61 PUSH2 0x1e01 1403 56 *JUMP // Stack delta = +6 // Outputs[11] // { // @135A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1360 memory[0x20:0x40] = 0x05 // @1397 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @139D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @13A6 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @13BE stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @13D5 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @13D6 stack[2] = 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 // @13FE stack[3] = 0x1404 // @13FF stack[4] = stack[-1] // @13FF stack[5] = memory[0x40:0x60] // } // Block ends with call to 0x1e01, returns to 0x1404 label_1404: // Incoming return from call to 0x1E01 at 0x1403 // Inputs[7] // { // @1407 memory[0x40:0x60] // @1409 stack[-1] // @140C stack[-3] // @140C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @140C stack[-2] // @140C stack[-4] // @1410 stack[-8] // } 1404 5B JUMPDEST 1405 60 PUSH1 0x40 1407 51 MLOAD 1408 80 DUP1 1409 91 SWAP2 140A 03 SUB 140B 90 SWAP1 140C A3 LOG3 140D 50 POP 140E 50 POP 140F 50 POP 1410 56 *JUMP // Stack delta = -8 // Outputs[1] { @140C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-8] label_1411: // Incoming call from 0x09CA, returns to 0x09CB // Incoming jump from 0x0DBE // Inputs[1] { @142A stack[-3] } 1411 5B JUMPDEST 1412 60 PUSH1 0x00 1414 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1429 16 AND 142A 83 DUP4 142B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1440 16 AND 1441 14 EQ 1442 15 ISZERO 1443 61 PUSH2 0x1481 1446 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1481, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1447: // Incoming jump from 0x1446, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1449 memory[0x40:0x60] } 1447 60 PUSH1 0x40 1449 51 MLOAD 144A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 146B 81 DUP2 146C 52 MSTORE 146D 60 PUSH1 0x04 146F 01 ADD 1470 61 PUSH2 0x1478 1473 90 SWAP1 1474 61 PUSH2 0x1ce1 1477 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @146C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1473 stack[0] = 0x1478 // @1473 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1ce1, returns to 0x1478 label_1478: // Incoming return from call to 0x1CE1 at 0x1477 // Inputs[3] // { // @147B memory[0x40:0x60] // @147D stack[-1] // @1480 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1478 5B JUMPDEST 1479 60 PUSH1 0x40 147B 51 MLOAD 147C 80 DUP1 147D 91 SWAP2 147E 03 SUB 147F 90 SWAP1 1480 FD *REVERT // Stack delta = -1 // Outputs[1] { @1480 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1481: // Incoming jump from 0x1446, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @149A stack[-2] } 1481 5B JUMPDEST 1482 60 PUSH1 0x00 1484 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1499 16 AND 149A 82 DUP3 149B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14B0 16 AND 14B1 14 EQ 14B2 15 ISZERO 14B3 61 PUSH2 0x14f1 14B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14f1, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_14B7: // Incoming jump from 0x14B6, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @14B9 memory[0x40:0x60] } 14B7 60 PUSH1 0x40 14B9 51 MLOAD 14BA 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 14DB 81 DUP2 14DC 52 MSTORE 14DD 60 PUSH1 0x04 14DF 01 ADD 14E0 61 PUSH2 0x14e8 14E3 90 SWAP1 14E4 61 PUSH2 0x1d61 14E7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @14E3 stack[0] = 0x14e8 // @14E3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1d61, returns to 0x14E8 label_14E8: // Incoming return from call to 0x1D61 at 0x14E7 // Inputs[3] // { // @14EB memory[0x40:0x60] // @14ED stack[-1] // @14F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 14E8 5B JUMPDEST 14E9 60 PUSH1 0x40 14EB 51 MLOAD 14EC 80 DUP1 14ED 91 SWAP2 14EE 03 SUB 14EF 90 SWAP1 14F0 FD *REVERT // Stack delta = -1 // Outputs[1] { @14F0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_14F1: // Incoming jump from 0x14B6, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @14F4 stack[-1] } 14F1 5B JUMPDEST 14F2 60 PUSH1 0x00 14F4 81 DUP2 14F5 11 GT 14F6 61 PUSH2 0x1534 14F9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1534, if stack[-1] > 0x00 label_14FA: // Incoming jump from 0x14F9, if not stack[-1] > 0x00 // Inputs[1] { @14FC memory[0x40:0x60] } 14FA 60 PUSH1 0x40 14FC 51 MLOAD 14FD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 151E 81 DUP2 151F 52 MSTORE 1520 60 PUSH1 0x04 1522 01 ADD 1523 61 PUSH2 0x152b 1526 90 SWAP1 1527 61 PUSH2 0x1da1 152A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @151F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1526 stack[0] = 0x152b // @1526 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1da1, returns to 0x152B label_152B: // Incoming return from call to 0x1DA1 at 0x152A // Inputs[3] // { // @152E memory[0x40:0x60] // @1530 stack[-1] // @1533 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 152B 5B JUMPDEST 152C 60 PUSH1 0x40 152E 51 MLOAD 152F 80 DUP1 1530 91 SWAP2 1531 03 SUB 1532 90 SWAP1 1533 FD *REVERT // Stack delta = -1 // Outputs[1] { @1533 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1534: // Incoming jump from 0x14F9, if stack[-1] > 0x00 // Inputs[3] // { // @1538 stack[-3] // @1539 stack[-2] // @153A stack[-1] // } 1534 5B JUMPDEST 1535 61 PUSH2 0x153f 1538 83 DUP4 1539 83 DUP4 153A 83 DUP4 153B 61 PUSH2 0x1544 153E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1535 stack[0] = 0x153f // @1538 stack[1] = stack[-3] // @1539 stack[2] = stack[-2] // @153A stack[3] = stack[-1] // } // Block ends with call to 0x1544, returns to 0x153F label_153F: // Incoming return from call to 0x1544 at 0x153E // Inputs[1] { @1543 stack[-4] } 153F 5B JUMPDEST 1540 50 POP 1541 50 POP 1542 50 POP 1543 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_1544: // Incoming call from 0x1158, returns to 0x1159 // Incoming call from 0x153E, returns to 0x153F // Inputs[1] { @1563 storage[0x01] } 1544 5B JUMPDEST 1545 60 PUSH1 0x00 1547 80 DUP1 1548 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 155D 16 AND 155E 60 PUSH1 0x01 1560 60 PUSH1 0x00 1562 90 SWAP1 1563 54 SLOAD 1564 90 SWAP1 1565 61 PUSH2 0x0100 1568 0A EXP 1569 90 SWAP1 156A 04 DIV 156B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1580 16 AND 1581 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1596 16 AND 1597 14 EQ 1598 61 PUSH2 0x1642 159B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1545 stack[0] = 0x00 } // Block ends with conditional jump to 0x1642, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 label_159C: // Incoming jump from 0x159B, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // Inputs[4] // { // @15A1 storage[0x01] // @15DC memory[0x40:0x60] // @15F0 memory[0x40:0x60] // @15F9 address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00).code.length // } 159C 60 PUSH1 0x01 159E 60 PUSH1 0x00 15A0 90 SWAP1 15A1 54 SLOAD 15A2 90 SWAP1 15A3 61 PUSH2 0x0100 15A6 0A EXP 15A7 90 SWAP1 15A8 04 DIV 15A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15BE 16 AND 15BF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15D4 16 AND 15D5 63 PUSH4 0x8d10b85a 15DA 60 PUSH1 0x40 15DC 51 MLOAD 15DD 81 DUP2 15DE 63 PUSH4 0xffffffff 15E3 16 AND 15E4 60 PUSH1 0xe0 15E6 1B SHL 15E7 81 DUP2 15E8 52 MSTORE 15E9 60 PUSH1 0x04 15EB 01 ADD 15EC 60 PUSH1 0x20 15EE 60 PUSH1 0x40 15F0 51 MLOAD 15F1 80 DUP1 15F2 83 DUP4 15F3 03 SUB 15F4 81 DUP2 15F5 60 PUSH1 0x00 15F7 87 DUP8 15F8 80 DUP1 15F9 3B EXTCODESIZE 15FA 15 ISZERO 15FB 80 DUP1 15FC 15 ISZERO 15FD 61 PUSH2 0x1605 1600 57 *JUMPI // Stack delta = +10 // Outputs[11] // { // @15D4 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 // @15D5 stack[1] = 0x8d10b85a // @15E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x8d10b85a) << 0xe0 // @15EB stack[2] = 0x04 + memory[0x40:0x60] // @15EC stack[3] = 0x20 // @15F0 stack[4] = memory[0x40:0x60] // @15F3 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @15F4 stack[6] = memory[0x40:0x60] // @15F5 stack[7] = 0x00 // @15F7 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 // @15FA stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x1605, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00).code.length label_1601: // Incoming jump from 0x1600, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00).code.length // Inputs[1] { @1604 memory[0x00:0x00] } 1601 60 PUSH1 0x00 1603 80 DUP1 1604 FD *REVERT // Stack delta = +0 // Outputs[1] { @1604 revert(memory[0x00:0x00]); } // Block terminates label_1605: // Incoming jump from 0x1600, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00).code.length // Inputs[9] // { // @1607 msg.gas // @1608 stack[-4] // @1608 stack[-5] // @1608 stack[-7] // @1608 stack[-6] // @1608 memory[stack[-4]:stack[-4] + stack[-5]] // @1608 stack[-3] // @1608 stack[-2] // @1608 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 1605 5B JUMPDEST 1606 50 POP 1607 5A GAS 1608 F1 CALL 1609 15 ISZERO 160A 80 DUP1 160B 15 ISZERO 160C 61 PUSH2 0x1619 160F 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1608 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1609 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 0x1619, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1610: // Incoming jump from 0x160F, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1610 returndata.length // @1614 returndata[0x00:0x00 + returndata.length] // @1615 returndata.length // @1618 memory[0x00:0x00 + returndata.length] // } 1610 3D RETURNDATASIZE 1611 60 PUSH1 0x00 1613 80 DUP1 1614 3E RETURNDATACOPY 1615 3D RETURNDATASIZE 1616 60 PUSH1 0x00 1618 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1614 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1618 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1619: // Incoming jump from 0x160F, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1620 memory[0x40:0x60] // @1621 returndata.length // } 1619 5B JUMPDEST 161A 50 POP 161B 50 POP 161C 50 POP 161D 50 POP 161E 60 PUSH1 0x40 1620 51 MLOAD 1621 3D RETURNDATASIZE 1622 60 PUSH1 0x1f 1624 19 NOT 1625 60 PUSH1 0x1f 1627 82 DUP3 1628 01 ADD 1629 16 AND 162A 82 DUP3 162B 01 ADD 162C 80 DUP1 162D 60 PUSH1 0x40 162F 52 MSTORE 1630 50 POP 1631 81 DUP2 1632 01 ADD 1633 90 SWAP1 1634 61 PUSH2 0x163d 1637 91 SWAP2 1638 90 SWAP1 1639 61 PUSH2 0x194d 163C 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @162F memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1637 stack[-4] = 0x163d // @1638 stack[-2] = memory[0x40:0x60] // @1638 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x194d, returns to 0x163D label_163D: // Incoming return from call to 0x194D at 0x163C 163D 5B JUMPDEST 163E 61 PUSH2 0x1645 1641 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1645 label_1642: // Incoming jump from 0x159B, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // Inputs[2] // { // @1646 stack[-1] // @167F stack[-3] // } 1642 5B JUMPDEST 1643 60 PUSH1 0x00 1645 5B JUMPDEST 1646 90 SWAP1 1647 50 POP 1648 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000000 1669 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 167E 16 AND 167F 83 DUP4 1680 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1695 16 AND 1696 14 EQ 1697 80 DUP1 1698 15 ISZERO 1699 61 PUSH2 0x16cf 169C 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1646 stack[-1] = 0x00 // @1696 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x0000000000000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x16cf, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x0000000000000000000000000000000000000000000000000000000000000000) label_169D: // Incoming jump from 0x169C, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x0000000000000000000000000000000000000000000000000000000000000000) // Incoming jump from 0x169C, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x0000000000000000000000000000000000000000000000000000000000000000) // Inputs[1] { @16B6 stack[-2] } 169D 50 POP 169E 60 PUSH1 0x00 16A0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16B5 16 AND 16B6 81 DUP2 16B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16CC 16 AND 16CD 14 EQ 16CE 15 ISZERO 16CF 5B JUMPDEST 16D0 15 ISZERO 16D1 61 PUSH2 0x16d8 16D4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x16d8, if !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_16D5: // Incoming jump from 0x16D4, if not !stack[-1] // Incoming jump from 0x16D4, if not !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[5] // { // @16D5 stack[-1] // @16D6 stack[-4] // @16D9 stack[-2] // @1718 memory[0x00:0x40] // @1719 storage[keccak256(memory[0x00:0x40])] // } 16D5 80 DUP1 16D6 93 SWAP4 16D7 50 POP 16D8 5B JUMPDEST 16D9 81 DUP2 16DA 60 PUSH1 0x04 16DC 60 PUSH1 0x00 16DE 86 DUP7 16DF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16F4 16 AND 16F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 170A 16 AND 170B 81 DUP2 170C 52 MSTORE 170D 60 PUSH1 0x20 170F 01 ADD 1710 90 SWAP1 1711 81 DUP2 1712 52 MSTORE 1713 60 PUSH1 0x20 1715 01 ADD 1716 60 PUSH1 0x00 1718 20 SHA3 1719 54 SLOAD 171A 10 LT 171B 15 ISZERO 171C 61 PUSH2 0x175a 171F 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @16D6 stack[-4] = stack[-1] // @170C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1712 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x175a, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) label_1720: // Incoming jump from 0x171F, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Incoming jump from 0x171F, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Inputs[1] { @1722 memory[0x40:0x60] } 1720 60 PUSH1 0x40 1722 51 MLOAD 1723 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1744 81 DUP2 1745 52 MSTORE 1746 60 PUSH1 0x04 1748 01 ADD 1749 61 PUSH2 0x1751 174C 90 SWAP1 174D 61 PUSH2 0x1de1 1750 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1745 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @174C stack[0] = 0x1751 // @174C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1de1, returns to 0x1751 label_1751: // Incoming return from call to 0x1DE1 at 0x1750 // Inputs[3] // { // @1754 memory[0x40:0x60] // @1756 stack[-1] // @1759 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1751 5B JUMPDEST 1752 60 PUSH1 0x40 1754 51 MLOAD 1755 80 DUP1 1756 91 SWAP2 1757 03 SUB 1758 90 SWAP1 1759 FD *REVERT // Stack delta = -1 // Outputs[1] { @1759 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_175A: // Incoming jump from 0x171F, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Incoming jump from 0x171F, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Inputs[4] // { // @175B stack[-2] // @1760 stack[-4] // @179A memory[0x00:0x40] // @179B storage[keccak256(memory[0x00:0x40])] // } 175A 5B JUMPDEST 175B 81 DUP2 175C 60 PUSH1 0x04 175E 60 PUSH1 0x00 1760 86 DUP7 1761 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1776 16 AND 1777 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 178C 16 AND 178D 81 DUP2 178E 52 MSTORE 178F 60 PUSH1 0x20 1791 01 ADD 1792 90 SWAP1 1793 81 DUP2 1794 52 MSTORE 1795 60 PUSH1 0x20 1797 01 ADD 1798 60 PUSH1 0x00 179A 20 SHA3 179B 54 SLOAD 179C 61 PUSH2 0x17a5 179F 91 SWAP2 17A0 90 SWAP1 17A1 61 PUSH2 0x207f 17A4 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @178E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1794 memory[0x20:0x40] = 0x04 // @179F stack[0] = 0x17a5 // @17A0 stack[1] = stack[-2] // @17A0 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x207f, returns to 0x17A5 label_17A5: // Incoming return from call to 0x207F at 0x17A4 // Inputs[7] // { // @17AA stack[-5] // @17E4 memory[0x00:0x40] // @17E5 stack[-1] // @17E9 stack[-3] // @17EE stack[-4] // @1828 memory[0x00:0x40] // @1829 storage[keccak256(memory[0x00:0x40])] // } 17A5 5B JUMPDEST 17A6 60 PUSH1 0x04 17A8 60 PUSH1 0x00 17AA 86 DUP7 17AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17C0 16 AND 17C1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17D6 16 AND 17D7 81 DUP2 17D8 52 MSTORE 17D9 60 PUSH1 0x20 17DB 01 ADD 17DC 90 SWAP1 17DD 81 DUP2 17DE 52 MSTORE 17DF 60 PUSH1 0x20 17E1 01 ADD 17E2 60 PUSH1 0x00 17E4 20 SHA3 17E5 81 DUP2 17E6 90 SWAP1 17E7 55 SSTORE 17E8 50 POP 17E9 81 DUP2 17EA 60 PUSH1 0x04 17EC 60 PUSH1 0x00 17EE 85 DUP6 17EF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1804 16 AND 1805 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 181A 16 AND 181B 81 DUP2 181C 52 MSTORE 181D 60 PUSH1 0x20 181F 01 ADD 1820 90 SWAP1 1821 81 DUP2 1822 52 MSTORE 1823 60 PUSH1 0x20 1825 01 ADD 1826 60 PUSH1 0x00 1828 20 SHA3 1829 54 SLOAD 182A 61 PUSH2 0x1833 182D 91 SWAP2 182E 90 SWAP1 182F 61 PUSH2 0x1e5e 1832 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @17D8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @17DE memory[0x20:0x40] = 0x04 // @17E7 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @181C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1822 memory[0x20:0x40] = 0x04 // @182D stack[-1] = 0x1833 // @182E stack[1] = storage[keccak256(memory[0x00:0x40])] // @182E stack[0] = stack[-3] // } // Block ends with call to 0x1e5e, returns to 0x1833 label_1833: // Incoming return from call to 0x1E5E at 0x1832 // Inputs[6] // { // @1838 stack[-4] // @1872 memory[0x00:0x40] // @1873 stack[-1] // @188E stack[-5] // @18C6 stack[-3] // @18C9 memory[0x40:0x60] // } 1833 5B JUMPDEST 1834 60 PUSH1 0x04 1836 60 PUSH1 0x00 1838 85 DUP6 1839 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 184E 16 AND 184F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1864 16 AND 1865 81 DUP2 1866 52 MSTORE 1867 60 PUSH1 0x20 1869 01 ADD 186A 90 SWAP1 186B 81 DUP2 186C 52 MSTORE 186D 60 PUSH1 0x20 186F 01 ADD 1870 60 PUSH1 0x00 1872 20 SHA3 1873 81 DUP2 1874 90 SWAP1 1875 55 SSTORE 1876 50 POP 1877 82 DUP3 1878 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 188D 16 AND 188E 84 DUP5 188F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18A4 16 AND 18A5 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 18C6 84 DUP5 18C7 60 PUSH1 0x40 18C9 51 MLOAD 18CA 61 PUSH2 0x18d3 18CD 91 SWAP2 18CE 90 SWAP1 18CF 61 PUSH2 0x1e01 18D2 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1866 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @186C memory[0x20:0x40] = 0x04 // @1875 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @188D stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @18A4 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @18A5 stack[1] = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef // @18CD stack[2] = 0x18d3 // @18CE stack[3] = stack[-3] // @18CE stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x1e01, returns to 0x18D3 label_18D3: // Incoming return from call to 0x1E01 at 0x18D2 // Inputs[7] // { // @18D6 memory[0x40:0x60] // @18D8 stack[-1] // @18DB stack[-2] // @18DB stack[-3] // @18DB stack[-4] // @18DB memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @18E0 stack[-9] // } 18D3 5B JUMPDEST 18D4 60 PUSH1 0x40 18D6 51 MLOAD 18D7 80 DUP1 18D8 91 SWAP2 18D9 03 SUB 18DA 90 SWAP1 18DB A3 LOG3 18DC 50 POP 18DD 50 POP 18DE 50 POP 18DF 50 POP 18E0 56 *JUMP // Stack delta = -9 // Outputs[1] { @18DB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-9] label_18E1: // Incoming call from 0x19F1, returns to 0x19F2 // Incoming call from 0x19E0, returns to 0x19E1 // Incoming call from 0x19AF, returns to 0x19B0 // Incoming call from 0x1A31, returns to 0x1A32 // Incoming call from 0x1943, returns to 0x1944 // Incoming call from 0x199E, returns to 0x199F // Inputs[2] // { // @18E4 stack[-1] // @18E5 msg.data[stack[-1]:stack[-1] + 0x20] // } 18E1 5B JUMPDEST 18E2 60 PUSH1 0x00 18E4 81 DUP2 18E5 35 CALLDATALOAD 18E6 90 SWAP1 18E7 50 POP 18E8 61 PUSH2 0x18f0 18EB 81 DUP2 18EC 61 PUSH2 0x24da 18EF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18E6 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @18E8 stack[1] = 0x18f0 // @18EB stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x24da, returns to 0x18F0 label_18F0: // Incoming return from call to 0x24DA at 0x18EF // Inputs[3] // { // @18F1 stack[-1] // @18F1 stack[-4] // @18F2 stack[-3] // } 18F0 5B JUMPDEST 18F1 92 SWAP3 18F2 91 SWAP2 18F3 50 POP 18F4 50 POP 18F5 56 *JUMP // Stack delta = -3 // Outputs[1] { @18F1 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_18F6: // Incoming call from 0x1970, returns to 0x1971 // Inputs[2] // { // @18F9 stack[-1] // @18FA memory[stack[-1]:stack[-1] + 0x20] // } 18F6 5B JUMPDEST 18F7 60 PUSH1 0x00 18F9 81 DUP2 18FA 51 MLOAD 18FB 90 SWAP1 18FC 50 POP 18FD 61 PUSH2 0x1905 1900 81 DUP2 1901 61 PUSH2 0x24da 1904 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18FB stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @18FD stack[1] = 0x1905 // @1900 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x24da, returns to 0x1905 label_1905: // Incoming return from call to 0x24DA at 0x1904 // Inputs[3] // { // @1906 stack[-4] // @1906 stack[-1] // @1907 stack[-3] // } 1905 5B JUMPDEST 1906 92 SWAP3 1907 91 SWAP2 1908 50 POP 1909 50 POP 190A 56 *JUMP // Stack delta = -3 // Outputs[1] { @1906 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_190B: // Incoming call from 0x1A42, returns to 0x1A43 // Incoming call from 0x1A02, returns to 0x1A03 // Inputs[2] // { // @190E stack[-1] // @190F msg.data[stack[-1]:stack[-1] + 0x20] // } 190B 5B JUMPDEST 190C 60 PUSH1 0x00 190E 81 DUP2 190F 35 CALLDATALOAD 1910 90 SWAP1 1911 50 POP 1912 61 PUSH2 0x191a 1915 81 DUP2 1916 61 PUSH2 0x24f1 1919 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1910 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1912 stack[1] = 0x191a // @1915 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x24f1, returns to 0x191A label_191A: // Incoming return from call to 0x24F1 at 0x1919 // Inputs[3] // { // @191B stack[-4] // @191B stack[-1] // @191C stack[-3] // } 191A 5B JUMPDEST 191B 92 SWAP3 191C 91 SWAP2 191D 50 POP 191E 50 POP 191F 56 *JUMP // Stack delta = -3 // Outputs[1] { @191B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1920: // Incoming call from 0x0211, returns to 0x0212 // Incoming call from 0x03B1, returns to 0x03B2 // Incoming call from 0x05BE, returns to 0x05BF // Inputs[2] // { // @1925 stack[-1] // @1926 stack[-2] // } 1920 5B JUMPDEST 1921 60 PUSH1 0x00 1923 60 PUSH1 0x20 1925 82 DUP3 1926 84 DUP5 1927 03 SUB 1928 12 SLT 1929 15 ISZERO 192A 61 PUSH2 0x1936 192D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1921 stack[0] = 0x00 } // Block ends with conditional jump to 0x1936, if !(stack[-2] - stack[-1] i< 0x20) label_192E: // Incoming jump from 0x192D, if not !(stack[-2] - stack[-1] i< 0x20) 192E 61 PUSH2 0x1935 1931 61 PUSH2 0x2213 1934 56 *JUMP // Stack delta = +1 // Outputs[1] { @192E stack[0] = 0x1935 } // Block ends with unconditional jump to 0x2213 1935 5B JUMPDEST label_1936: // Incoming jump from 0x192D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @193C stack[-3] // @193E stack[-2] // } 1936 5B JUMPDEST 1937 60 PUSH1 0x00 1939 61 PUSH2 0x1944 193C 84 DUP5 193D 82 DUP3 193E 85 DUP6 193F 01 ADD 1940 61 PUSH2 0x18e1 1943 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1937 stack[0] = 0x00 // @1939 stack[1] = 0x1944 // @193C stack[2] = stack[-3] // @193F stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x18e1, returns to 0x1944 label_1944: // Incoming return from call to 0x18E1 at 0x1943 // Inputs[4] // { // @1945 stack[-3] // @1945 stack[-1] // @1948 stack[-6] // @1949 stack[-5] // } 1944 5B JUMPDEST 1945 91 SWAP2 1946 50 POP 1947 50 POP 1948 92 SWAP3 1949 91 SWAP2 194A 50 POP 194B 50 POP 194C 56 *JUMP // Stack delta = -5 // Outputs[1] { @1948 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_194D: // Incoming call from 0x163C, returns to 0x163D // Inputs[2] // { // @1952 stack[-1] // @1953 stack[-2] // } 194D 5B JUMPDEST 194E 60 PUSH1 0x00 1950 60 PUSH1 0x20 1952 82 DUP3 1953 84 DUP5 1954 03 SUB 1955 12 SLT 1956 15 ISZERO 1957 61 PUSH2 0x1963 195A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @194E stack[0] = 0x00 } // Block ends with conditional jump to 0x1963, if !(stack[-2] - stack[-1] i< 0x20) label_195B: // Incoming jump from 0x195A, if not !(stack[-2] - stack[-1] i< 0x20) 195B 61 PUSH2 0x1962 195E 61 PUSH2 0x2213 1961 56 *JUMP // Stack delta = +1 // Outputs[1] { @195B stack[0] = 0x1962 } // Block ends with unconditional jump to 0x2213 1962 5B JUMPDEST label_1963: // Incoming jump from 0x195A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1969 stack[-3] // @196B stack[-2] // } 1963 5B JUMPDEST 1964 60 PUSH1 0x00 1966 61 PUSH2 0x1971 1969 84 DUP5 196A 82 DUP3 196B 85 DUP6 196C 01 ADD 196D 61 PUSH2 0x18f6 1970 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1964 stack[0] = 0x00 // @1966 stack[1] = 0x1971 // @1969 stack[2] = stack[-3] // @196C stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x18f6, returns to 0x1971 label_1971: // Incoming return from call to 0x18F6 at 0x1970 // Inputs[4] // { // @1972 stack[-1] // @1972 stack[-3] // @1975 stack[-6] // @1976 stack[-5] // } 1971 5B JUMPDEST 1972 91 SWAP2 1973 50 POP 1974 50 POP 1975 92 SWAP3 1976 91 SWAP2 1977 50 POP 1978 50 POP 1979 56 *JUMP // Stack delta = -5 // Outputs[1] { @1975 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_197A: // Incoming call from 0x056A, returns to 0x056B // Inputs[2] // { // @1980 stack[-1] // @1981 stack[-2] // } 197A 5B JUMPDEST 197B 60 PUSH1 0x00 197D 80 DUP1 197E 60 PUSH1 0x40 1980 83 DUP4 1981 85 DUP6 1982 03 SUB 1983 12 SLT 1984 15 ISZERO 1985 61 PUSH2 0x1991 1988 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @197B stack[0] = 0x00 // @197D stack[1] = 0x00 // } // Block ends with conditional jump to 0x1991, if !(stack[-2] - stack[-1] i< 0x40) label_1989: // Incoming jump from 0x1988, if not !(stack[-2] - stack[-1] i< 0x40) 1989 61 PUSH2 0x1990 198C 61 PUSH2 0x2213 198F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1989 stack[0] = 0x1990 } // Block ends with unconditional jump to 0x2213 1990 5B JUMPDEST label_1991: // Incoming jump from 0x1988, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1997 stack[-4] // @1999 stack[-3] // } 1991 5B JUMPDEST 1992 60 PUSH1 0x00 1994 61 PUSH2 0x199f 1997 85 DUP6 1998 82 DUP3 1999 86 DUP7 199A 01 ADD 199B 61 PUSH2 0x18e1 199E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1992 stack[0] = 0x00 // @1994 stack[1] = 0x199f // @1997 stack[2] = stack[-4] // @199A stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x18e1, returns to 0x199F label_199F: // Incoming return from call to 0x18E1 at 0x199E // Inputs[4] // { // @19A0 stack[-4] // @19A0 stack[-1] // @19A8 stack[-6] // @19AA stack[-5] // } 199F 5B JUMPDEST 19A0 92 SWAP3 19A1 50 POP 19A2 50 POP 19A3 60 PUSH1 0x20 19A5 61 PUSH2 0x19b0 19A8 85 DUP6 19A9 82 DUP3 19AA 86 DUP7 19AB 01 ADD 19AC 61 PUSH2 0x18e1 19AF 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @19A0 stack[-4] = stack[-1] // @19A3 stack[-2] = 0x20 // @19A5 stack[-1] = 0x19b0 // @19A8 stack[0] = stack[-6] // @19AB stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x18e1, returns to 0x19B0 label_19B0: // Incoming return from call to 0x18E1 at 0x19AF // Inputs[6] // { // @19B1 stack[-1] // @19B1 stack[-3] // @19B4 stack[-6] // @19B6 stack[-4] // @19B6 stack[-7] // @19B7 stack[-5] // } 19B0 5B JUMPDEST 19B1 91 SWAP2 19B2 50 POP 19B3 50 POP 19B4 92 SWAP3 19B5 50 POP 19B6 92 SWAP3 19B7 90 SWAP1 19B8 50 POP 19B9 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @19B4 stack[-6] = stack[-1] // @19B6 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_19BA: // Incoming call from 0x02E1, returns to 0x02E2 // Inputs[2] // { // @19C2 stack[-1] // @19C3 stack[-2] // } 19BA 5B JUMPDEST 19BB 60 PUSH1 0x00 19BD 80 DUP1 19BE 60 PUSH1 0x00 19C0 60 PUSH1 0x60 19C2 84 DUP5 19C3 86 DUP7 19C4 03 SUB 19C5 12 SLT 19C6 15 ISZERO 19C7 61 PUSH2 0x19d3 19CA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @19BB stack[0] = 0x00 // @19BD stack[1] = 0x00 // @19BE stack[2] = 0x00 // } // Block ends with conditional jump to 0x19d3, if !(stack[-2] - stack[-1] i< 0x60) label_19CB: // Incoming jump from 0x19CA, if not !(stack[-2] - stack[-1] i< 0x60) 19CB 61 PUSH2 0x19d2 19CE 61 PUSH2 0x2213 19D1 56 *JUMP // Stack delta = +1 // Outputs[1] { @19CB stack[0] = 0x19d2 } // Block ends with unconditional jump to 0x2213 19D2 5B JUMPDEST label_19D3: // Incoming jump from 0x19CA, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @19D9 stack[-5] // @19DB stack[-4] // } 19D3 5B JUMPDEST 19D4 60 PUSH1 0x00 19D6 61 PUSH2 0x19e1 19D9 86 DUP7 19DA 82 DUP3 19DB 87 DUP8 19DC 01 ADD 19DD 61 PUSH2 0x18e1 19E0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19D4 stack[0] = 0x00 // @19D6 stack[1] = 0x19e1 // @19D9 stack[2] = stack[-5] // @19DC stack[3] = stack[-4] + 0x00 // } // Block ends with call to 0x18e1, returns to 0x19E1 label_19E1: // Incoming return from call to 0x18E1 at 0x19E0 // Inputs[4] // { // @19E2 stack[-5] // @19E2 stack[-1] // @19EA stack[-7] // @19EC stack[-6] // } 19E1 5B JUMPDEST 19E2 93 SWAP4 19E3 50 POP 19E4 50 POP 19E5 60 PUSH1 0x20 19E7 61 PUSH2 0x19f2 19EA 86 DUP7 19EB 82 DUP3 19EC 87 DUP8 19ED 01 ADD 19EE 61 PUSH2 0x18e1 19F1 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @19E2 stack[-5] = stack[-1] // @19E5 stack[-2] = 0x20 // @19E7 stack[-1] = 0x19f2 // @19EA stack[0] = stack[-7] // @19ED stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x18e1, returns to 0x19F2 label_19F2: // Incoming return from call to 0x18E1 at 0x19F1 // Inputs[4] // { // @19F3 stack[-4] // @19F3 stack[-1] // @19FB stack[-7] // @19FD stack[-6] // } 19F2 5B JUMPDEST 19F3 92 SWAP3 19F4 50 POP 19F5 50 POP 19F6 60 PUSH1 0x40 19F8 61 PUSH2 0x1a03 19FB 86 DUP7 19FC 82 DUP3 19FD 87 DUP8 19FE 01 ADD 19FF 61 PUSH2 0x190b 1A02 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @19F3 stack[-4] = stack[-1] // @19F6 stack[-2] = 0x40 // @19F8 stack[-1] = 0x1a03 // @19FB stack[0] = stack[-7] // @19FE stack[1] = stack[-6] + 0x40 // } // Block ends with call to 0x190b, returns to 0x1A03 label_1A03: // Incoming return from call to 0x190B at 0x1A02 // Inputs[7] // { // @1A04 stack[-1] // @1A04 stack[-3] // @1A07 stack[-6] // @1A09 stack[-4] // @1A09 stack[-7] // @1A0B stack[-8] // @1A0B stack[-5] // } 1A03 5B JUMPDEST 1A04 91 SWAP2 1A05 50 POP 1A06 50 POP 1A07 92 SWAP3 1A08 50 POP 1A09 92 SWAP3 1A0A 50 POP 1A0B 92 SWAP3 1A0C 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1A07 stack[-6] = stack[-1] // @1A09 stack[-7] = stack[-4] // @1A0B stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_1A0D: // Incoming call from 0x0279, returns to 0x027A // Incoming call from 0x04AC, returns to 0x04AD // Incoming call from 0x046F, returns to 0x0470 // Incoming call from 0x0349, returns to 0x034A // Inputs[2] // { // @1A13 stack[-1] // @1A14 stack[-2] // } 1A0D 5B JUMPDEST 1A0E 60 PUSH1 0x00 1A10 80 DUP1 1A11 60 PUSH1 0x40 1A13 83 DUP4 1A14 85 DUP6 1A15 03 SUB 1A16 12 SLT 1A17 15 ISZERO 1A18 61 PUSH2 0x1a24 1A1B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A0E stack[0] = 0x00 // @1A10 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a24, if !(stack[-2] - stack[-1] i< 0x40) label_1A1C: // Incoming jump from 0x1A1B, if not !(stack[-2] - stack[-1] i< 0x40) 1A1C 61 PUSH2 0x1a23 1A1F 61 PUSH2 0x2213 1A22 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A1C stack[0] = 0x1a23 } // Block ends with unconditional jump to 0x2213 1A23 5B JUMPDEST label_1A24: // Incoming jump from 0x1A1B, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1A2A stack[-4] // @1A2C stack[-3] // } 1A24 5B JUMPDEST 1A25 60 PUSH1 0x00 1A27 61 PUSH2 0x1a32 1A2A 85 DUP6 1A2B 82 DUP3 1A2C 86 DUP7 1A2D 01 ADD 1A2E 61 PUSH2 0x18e1 1A31 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A25 stack[0] = 0x00 // @1A27 stack[1] = 0x1a32 // @1A2A stack[2] = stack[-4] // @1A2D stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x18e1, returns to 0x1A32 label_1A32: // Incoming return from call to 0x18E1 at 0x1A31 // Inputs[4] // { // @1A33 stack[-4] // @1A33 stack[-1] // @1A3B stack[-6] // @1A3D stack[-5] // } 1A32 5B JUMPDEST 1A33 92 SWAP3 1A34 50 POP 1A35 50 POP 1A36 60 PUSH1 0x20 1A38 61 PUSH2 0x1a43 1A3B 85 DUP6 1A3C 82 DUP3 1A3D 86 DUP7 1A3E 01 ADD 1A3F 61 PUSH2 0x190b 1A42 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1A33 stack[-4] = stack[-1] // @1A36 stack[-2] = 0x20 // @1A38 stack[-1] = 0x1a43 // @1A3B stack[0] = stack[-6] // @1A3E stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x190b, returns to 0x1A43 label_1A43: // Incoming return from call to 0x190B at 0x1A42 // Inputs[6] // { // @1A44 stack[-1] // @1A44 stack[-3] // @1A47 stack[-6] // @1A49 stack[-7] // @1A49 stack[-4] // @1A4A stack[-5] // } 1A43 5B JUMPDEST 1A44 91 SWAP2 1A45 50 POP 1A46 50 POP 1A47 92 SWAP3 1A48 50 POP 1A49 92 SWAP3 1A4A 90 SWAP1 1A4B 50 POP 1A4C 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1A47 stack[-6] = stack[-1] // @1A49 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1A4D: // Incoming call from 0x1C67, returns to 0x1C68 // Inputs[1] { @1A51 stack[-1] } 1A4D 5B JUMPDEST 1A4E 61 PUSH2 0x1a56 1A51 81 DUP2 1A52 61 PUSH2 0x20b3 1A55 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A4E stack[0] = 0x1a56 // @1A51 stack[1] = stack[-1] // } // Block ends with call to 0x20b3, returns to 0x1A56 label_1A56: // Incoming return from call to 0x20B3 at 0x1A55 // Inputs[3] // { // @1A57 stack[-3] // @1A58 stack[-1] // @1A5B stack[-4] // } 1A56 5B JUMPDEST 1A57 82 DUP3 1A58 52 MSTORE 1A59 50 POP 1A5A 50 POP 1A5B 56 *JUMP // Stack delta = -4 // Outputs[1] { @1A58 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1A5C: // Incoming call from 0x1C82, returns to 0x1C83 // Inputs[1] { @1A60 stack[-1] } 1A5C 5B JUMPDEST 1A5D 61 PUSH2 0x1a65 1A60 81 DUP2 1A61 61 PUSH2 0x20c5 1A64 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A5D stack[0] = 0x1a65 // @1A60 stack[1] = stack[-1] // } // Block ends with call to 0x20c5, returns to 0x1A65 label_1A65: // Incoming return from call to 0x20C5 at 0x1A64 // Inputs[3] // { // @1A66 stack[-3] // @1A67 stack[-1] // @1A6A stack[-4] // } 1A65 5B JUMPDEST 1A66 82 DUP3 1A67 52 MSTORE 1A68 50 POP 1A69 50 POP 1A6A 56 *JUMP // Stack delta = -4 // Outputs[1] { @1A67 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1A6B: // Incoming call from 0x1C9D, returns to 0x1C9E // Inputs[1] { @1A6F stack[-1] } 1A6B 5B JUMPDEST 1A6C 61 PUSH2 0x1a74 1A6F 81 DUP2 1A70 61 PUSH2 0x2108 1A73 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A6C stack[0] = 0x1a74 // @1A6F stack[1] = stack[-1] // } // Block ends with call to 0x2108, returns to 0x1A74 label_1A74: // Incoming return from call to 0x2108 at 0x1A73 // Inputs[3] // { // @1A75 stack[-3] // @1A76 stack[-1] // @1A79 stack[-4] // } 1A74 5B JUMPDEST 1A75 82 DUP3 1A76 52 MSTORE 1A77 50 POP 1A78 50 POP 1A79 56 *JUMP // Stack delta = -4 // Outputs[1] { @1A76 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1A7A: // Incoming call from 0x1CB8, returns to 0x1CB9 // Inputs[1] { @1A7E stack[-1] } 1A7A 5B JUMPDEST 1A7B 61 PUSH2 0x1a83 1A7E 81 DUP2 1A7F 61 PUSH2 0x212c 1A82 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A7B stack[0] = 0x1a83 // @1A7E stack[1] = stack[-1] // } // Block ends with call to 0x212c, returns to 0x1A83 label_1A83: // Incoming return from call to 0x212C at 0x1A82 // Inputs[3] // { // @1A84 stack[-3] // @1A85 stack[-1] // @1A88 stack[-4] // } 1A83 5B JUMPDEST 1A84 82 DUP3 1A85 52 MSTORE 1A86 50 POP 1A87 50 POP 1A88 56 *JUMP // Stack delta = -4 // Outputs[1] { @1A85 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1A89: // Incoming call from 0x1CD8, returns to 0x1CD9 // Inputs[1] { @1A8F stack[-1] } 1A89 5B JUMPDEST 1A8A 60 PUSH1 0x00 1A8C 61 PUSH2 0x1a94 1A8F 82 DUP3 1A90 61 PUSH2 0x1e37 1A93 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A8A stack[0] = 0x00 // @1A8C stack[1] = 0x1a94 // @1A8F stack[2] = stack[-1] // } // Block ends with call to 0x1e37, returns to 0x1A94 label_1A94: // Incoming return from call to 0x1E37 at 0x1A93 // Inputs[2] // { // @1A98 stack[-1] // @1A99 stack[-4] // } 1A94 5B JUMPDEST 1A95 61 PUSH2 0x1a9e 1A98 81 DUP2 1A99 85 DUP6 1A9A 61 PUSH2 0x1e4d 1A9D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A95 stack[0] = 0x1a9e // @1A98 stack[1] = stack[-1] // @1A99 stack[2] = stack[-4] // } // Block ends with call to 0x1e4d, returns to 0x1A9E label_1A9E: // Incoming return from call to 0x1E4D at 0x1A9D // Inputs[4] // { // @1A9F stack[-5] // @1A9F stack[-1] // @1AA4 stack[-2] // @1AA8 stack[-4] // } 1A9E 5B JUMPDEST 1A9F 93 SWAP4 1AA0 50 POP 1AA1 61 PUSH2 0x1aae 1AA4 81 DUP2 1AA5 85 DUP6 1AA6 60 PUSH1 0x20 1AA8 86 DUP7 1AA9 01 ADD 1AAA 61 PUSH2 0x2150 1AAD 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1A9F stack[-5] = stack[-1] // @1AA1 stack[-1] = 0x1aae // @1AA4 stack[0] = stack[-2] // @1AA5 stack[1] = stack[-1] // @1AA9 stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x2150, returns to 0x1AAE label_1AAE: // Incoming return from call to 0x2150 at 0x1AAD // Inputs[1] { @1AB2 stack[-1] } 1AAE 5B JUMPDEST 1AAF 61 PUSH2 0x1ab7 1AB2 81 DUP2 1AB3 61 PUSH2 0x2218 1AB6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1AAF stack[0] = 0x1ab7 // @1AB2 stack[1] = stack[-1] // } // Block ends with call to 0x2218, returns to 0x1AB7 label_1AB7: // Incoming return from call to 0x2218 at 0x1AB6 // Inputs[4] // { // @1AB8 stack[-5] // @1AB9 stack[-1] // @1ABA stack[-3] // @1ABD stack[-6] // } 1AB7 5B JUMPDEST 1AB8 84 DUP5 1AB9 01 ADD 1ABA 91 SWAP2 1ABB 50 POP 1ABC 50 POP 1ABD 92 SWAP3 1ABE 91 SWAP2 1ABF 50 POP 1AC0 50 POP 1AC1 56 *JUMP // Stack delta = -5 // Outputs[1] { @1ABD stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_1AC2: // Incoming call from 0x1CF9, returns to 0x1CFA // Inputs[1] { @1ACA stack[-1] } 1AC2 5B JUMPDEST 1AC3 60 PUSH1 0x00 1AC5 61 PUSH2 0x1acf 1AC8 60 PUSH1 0x26 1ACA 83 DUP4 1ACB 61 PUSH2 0x1e4d 1ACE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AC3 stack[0] = 0x00 // @1AC5 stack[1] = 0x1acf // @1AC8 stack[2] = 0x26 // @1ACA stack[3] = stack[-1] // } // Block ends with call to 0x1e4d, returns to 0x1ACF label_1ACF: // Incoming return from call to 0x1E4D at 0x1ACE // Inputs[2] // { // @1AD0 stack[-1] // @1AD0 stack[-3] // } 1ACF 5B JUMPDEST 1AD0 91 SWAP2 1AD1 50 POP 1AD2 61 PUSH2 0x1ada 1AD5 82 DUP3 1AD6 61 PUSH2 0x2236 1AD9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1AD0 stack[-3] = stack[-1] // @1AD2 stack[-1] = 0x1ada // @1AD5 stack[0] = stack[-1] // } // Block ends with call to 0x2236, returns to 0x1ADA label_1ADA: // Incoming return from call to 0x2236 at 0x1AD9 // Inputs[3] // { // @1ADD stack[-2] // @1ADF stack[-1] // @1AE1 stack[-3] // } 1ADA 5B JUMPDEST 1ADB 60 PUSH1 0x40 1ADD 82 DUP3 1ADE 01 ADD 1ADF 90 SWAP1 1AE0 50 POP 1AE1 91 SWAP2 1AE2 90 SWAP1 1AE3 50 POP 1AE4 56 *JUMP // Stack delta = -2 // Outputs[1] { @1AE1 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1AE5: // Incoming call from 0x1D19, returns to 0x1D1A // Inputs[1] { @1AED stack[-1] } 1AE5 5B JUMPDEST 1AE6 60 PUSH1 0x00 1AE8 61 PUSH2 0x1af2 1AEB 60 PUSH1 0x26 1AED 83 DUP4 1AEE 61 PUSH2 0x1e4d 1AF1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AE6 stack[0] = 0x00 // @1AE8 stack[1] = 0x1af2 // @1AEB stack[2] = 0x26 // @1AED stack[3] = stack[-1] // } // Block ends with call to 0x1e4d, returns to 0x1AF2 label_1AF2: // Incoming return from call to 0x1E4D at 0x1AF1 // Inputs[2] // { // @1AF3 stack[-3] // @1AF3 stack[-1] // } 1AF2 5B JUMPDEST 1AF3 91 SWAP2 1AF4 50 POP 1AF5 61 PUSH2 0x1afd 1AF8 82 DUP3 1AF9 61 PUSH2 0x2285 1AFC 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1AF3 stack[-3] = stack[-1] // @1AF5 stack[-1] = 0x1afd // @1AF8 stack[0] = stack[-1] // } // Block ends with call to 0x2285, returns to 0x1AFD label_1AFD: // Incoming return from call to 0x2285 at 0x1AFC // Inputs[3] // { // @1B00 stack[-2] // @1B02 stack[-1] // @1B04 stack[-3] // } 1AFD 5B JUMPDEST 1AFE 60 PUSH1 0x40 1B00 82 DUP3 1B01 01 ADD 1B02 90 SWAP1 1B03 50 POP 1B04 91 SWAP2 1B05 90 SWAP1 1B06 50 POP 1B07 56 *JUMP // Stack delta = -2 // Outputs[1] { @1B04 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1B08: // Incoming call from 0x1D39, returns to 0x1D3A // Inputs[1] { @1B10 stack[-1] } 1B08 5B JUMPDEST 1B09 60 PUSH1 0x00 1B0B 61 PUSH2 0x1b15 1B0E 60 PUSH1 0x23 1B10 83 DUP4 1B11 61 PUSH2 0x1e4d 1B14 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B09 stack[0] = 0x00 // @1B0B stack[1] = 0x1b15 // @1B0E stack[2] = 0x23 // @1B10 stack[3] = stack[-1] // } // Block ends with call to 0x1e4d, returns to 0x1B15 label_1B15: // Incoming return from call to 0x1E4D at 0x1B14 // Inputs[2] // { // @1B16 stack[-3] // @1B16 stack[-1] // } 1B15 5B JUMPDEST 1B16 91 SWAP2 1B17 50 POP 1B18 61 PUSH2 0x1b20 1B1B 82 DUP3 1B1C 61 PUSH2 0x22d4 1B1F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1B16 stack[-3] = stack[-1] // @1B18 stack[-1] = 0x1b20 // @1B1B stack[0] = stack[-1] // } // Block ends with call to 0x22d4, returns to 0x1B20 label_1B20: // Incoming return from call to 0x22D4 at 0x1B1F // Inputs[3] // { // @1B23 stack[-2] // @1B25 stack[-1] // @1B27 stack[-3] // } 1B20 5B JUMPDEST 1B21 60 PUSH1 0x40 1B23 82 DUP3 1B24 01 ADD 1B25 90 SWAP1 1B26 50 POP 1B27 91 SWAP2 1B28 90 SWAP1 1B29 50 POP 1B2A 56 *JUMP // Stack delta = -2 // Outputs[1] { @1B27 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1B2B: // Incoming call from 0x1D59, returns to 0x1D5A // Inputs[1] { @1B33 stack[-1] } 1B2B 5B JUMPDEST 1B2C 60 PUSH1 0x00 1B2E 61 PUSH2 0x1b38 1B31 60 PUSH1 0x11 1B33 83 DUP4 1B34 61 PUSH2 0x1e4d 1B37 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B2C stack[0] = 0x00 // @1B2E stack[1] = 0x1b38 // @1B31 stack[2] = 0x11 // @1B33 stack[3] = stack[-1] // } // Block ends with call to 0x1e4d, returns to 0x1B38 label_1B38: // Incoming return from call to 0x1E4D at 0x1B37 // Inputs[2] // { // @1B39 stack[-1] // @1B39 stack[-3] // } 1B38 5B JUMPDEST 1B39 91 SWAP2 1B3A 50 POP 1B3B 61 PUSH2 0x1b43 1B3E 82 DUP3 1B3F 61 PUSH2 0x2323 1B42 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1B39 stack[-3] = stack[-1] // @1B3B stack[-1] = 0x1b43 // @1B3E stack[0] = stack[-1] // } // Block ends with call to 0x2323, returns to 0x1B43 label_1B43: // Incoming return from call to 0x2323 at 0x1B42 // Inputs[3] // { // @1B46 stack[-2] // @1B48 stack[-1] // @1B4A stack[-3] // } 1B43 5B JUMPDEST 1B44 60 PUSH1 0x20 1B46 82 DUP3 1B47 01 ADD 1B48 90 SWAP1 1B49 50 POP 1B4A 91 SWAP2 1B4B 90 SWAP1 1B4C 50 POP 1B4D 56 *JUMP // Stack delta = -2 // Outputs[1] { @1B4A stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_1B4E: // Incoming call from 0x1D79, returns to 0x1D7A // Inputs[1] { @1B56 stack[-1] } 1B4E 5B JUMPDEST 1B4F 60 PUSH1 0x00 1B51 61 PUSH2 0x1b5b 1B54 60 PUSH1 0x24 1B56 83 DUP4 1B57 61 PUSH2 0x1e4d 1B5A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B4F stack[0] = 0x00 // @1B51 stack[1] = 0x1b5b // @1B54 stack[2] = 0x24 // @1B56 stack[3] = stack[-1] // } // Block ends with call to 0x1e4d, returns to 0x1B5B label_1B5B: // Incoming return from call to 0x1E4D at 0x1B5A // Inputs[2] // { // @1B5C stack[-3] // @1B5C stack[-1] // } 1B5B 5B JUMPDEST 1B5C 91 SWAP2 1B5D 50 POP 1B5E 61 PUSH2 0x1b66 1B61 82 DUP3 1B62 61 PUSH2 0x234c 1B65 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1B5C stack[-3] = stack[-1] // @1B5E stack[-1] = 0x1b66 // @1B61 stack[0] = stack[-1] // } // Block ends with call to 0x234c, returns to 0x1B66 label_1B66: // Incoming return from call to 0x234C at 0x1B65 // Inputs[3] // { // @1B69 stack[-2] // @1B6B stack[-1] // @1B6D stack[-3] // } 1B66 5B JUMPDEST 1B67 60 PUSH1 0x40 1B69 82 DUP3 1B6A 01 ADD 1B6B 90 SWAP1 1B6C 50 POP 1B6D 91 SWAP2 1B6E 90 SWAP1 1B6F 50 POP 1B70 56 *JUMP // Stack delta = -2 // Outputs[1] { @1B6D stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1B71: // Incoming call from 0x1C48, returns to 0x1C49 // Inputs[1] { @1B79 stack[-1] } 1B71 5B JUMPDEST 1B72 60 PUSH1 0x00 1B74 61 PUSH2 0x1b7e 1B77 60 PUSH1 0x00 1B79 83 DUP4 1B7A 61 PUSH2 0x1e42 1B7D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B72 stack[0] = 0x00 // @1B74 stack[1] = 0x1b7e // @1B77 stack[2] = 0x00 // @1B79 stack[3] = stack[-1] // } // Block ends with call to 0x1e42, returns to 0x1B7E label_1B7E: // Incoming return from call to 0x1E42 at 0x1B7D // Inputs[2] // { // @1B7F stack[-3] // @1B7F stack[-1] // } 1B7E 5B JUMPDEST 1B7F 91 SWAP2 1B80 50 POP 1B81 61 PUSH2 0x1b89 1B84 82 DUP3 1B85 61 PUSH2 0x239b 1B88 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1B7F stack[-3] = stack[-1] // @1B81 stack[-1] = 0x1b89 // @1B84 stack[0] = stack[-1] // } // Block ends with call to 0x239b, returns to 0x1B89 label_1B89: // Incoming return from call to 0x239B at 0x1B88 // Inputs[3] // { // @1B8C stack[-2] // @1B8E stack[-1] // @1B90 stack[-3] // } 1B89 5B JUMPDEST 1B8A 60 PUSH1 0x00 1B8C 82 DUP3 1B8D 01 ADD 1B8E 90 SWAP1 1B8F 50 POP 1B90 91 SWAP2 1B91 90 SWAP1 1B92 50 POP 1B93 56 *JUMP // Stack delta = -2 // Outputs[1] { @1B90 stack[-3] = stack[-2] + 0x00 } // Block ends with unconditional jump to stack[-3] label_1B94: // Incoming call from 0x1D99, returns to 0x1D9A // Inputs[1] { @1B9C stack[-1] } 1B94 5B JUMPDEST 1B95 60 PUSH1 0x00 1B97 61 PUSH2 0x1ba1 1B9A 60 PUSH1 0x25 1B9C 83 DUP4 1B9D 61 PUSH2 0x1e4d 1BA0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B95 stack[0] = 0x00 // @1B97 stack[1] = 0x1ba1 // @1B9A stack[2] = 0x25 // @1B9C stack[3] = stack[-1] // } // Block ends with call to 0x1e4d, returns to 0x1BA1 label_1BA1: // Incoming return from call to 0x1E4D at 0x1BA0 // Inputs[2] // { // @1BA2 stack[-1] // @1BA2 stack[-3] // } 1BA1 5B JUMPDEST 1BA2 91 SWAP2 1BA3 50 POP 1BA4 61 PUSH2 0x1bac 1BA7 82 DUP3 1BA8 61 PUSH2 0x239e 1BAB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1BA2 stack[-3] = stack[-1] // @1BA4 stack[-1] = 0x1bac // @1BA7 stack[0] = stack[-1] // } // Block ends with call to 0x239e, returns to 0x1BAC label_1BAC: // Incoming return from call to 0x239E at 0x1BAB // Inputs[3] // { // @1BAF stack[-2] // @1BB1 stack[-1] // @1BB3 stack[-3] // } 1BAC 5B JUMPDEST 1BAD 60 PUSH1 0x40 1BAF 82 DUP3 1BB0 01 ADD 1BB1 90 SWAP1 1BB2 50 POP 1BB3 91 SWAP2 1BB4 90 SWAP1 1BB5 50 POP 1BB6 56 *JUMP // Stack delta = -2 // Outputs[1] { @1BB3 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1BB7: // Incoming call from 0x1DB9, returns to 0x1DBA // Inputs[1] { @1BBF stack[-1] } 1BB7 5B JUMPDEST 1BB8 60 PUSH1 0x00 1BBA 61 PUSH2 0x1bc4 1BBD 60 PUSH1 0x31 1BBF 83 DUP4 1BC0 61 PUSH2 0x1e4d 1BC3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BB8 stack[0] = 0x00 // @1BBA stack[1] = 0x1bc4 // @1BBD stack[2] = 0x31 // @1BBF stack[3] = stack[-1] // } // Block ends with call to 0x1e4d, returns to 0x1BC4 label_1BC4: // Incoming return from call to 0x1E4D at 0x1BC3 // Inputs[2] // { // @1BC5 stack[-1] // @1BC5 stack[-3] // } 1BC4 5B JUMPDEST 1BC5 91 SWAP2 1BC6 50 POP 1BC7 61 PUSH2 0x1bcf 1BCA 82 DUP3 1BCB 61 PUSH2 0x23ed 1BCE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1BC5 stack[-3] = stack[-1] // @1BC7 stack[-1] = 0x1bcf // @1BCA stack[0] = stack[-1] // } // Block ends with call to 0x23ed, returns to 0x1BCF label_1BCF: // Incoming return from call to 0x23ED at 0x1BCE // Inputs[3] // { // @1BD2 stack[-2] // @1BD4 stack[-1] // @1BD6 stack[-3] // } 1BCF 5B JUMPDEST 1BD0 60 PUSH1 0x40 1BD2 82 DUP3 1BD3 01 ADD 1BD4 90 SWAP1 1BD5 50 POP 1BD6 91 SWAP2 1BD7 90 SWAP1 1BD8 50 POP 1BD9 56 *JUMP // Stack delta = -2 // Outputs[1] { @1BD6 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1BDA: // Incoming call from 0x1DD9, returns to 0x1DDA // Inputs[1] { @1BE2 stack[-1] } 1BDA 5B JUMPDEST 1BDB 60 PUSH1 0x00 1BDD 61 PUSH2 0x1be7 1BE0 60 PUSH1 0x29 1BE2 83 DUP4 1BE3 61 PUSH2 0x1e4d 1BE6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BDB stack[0] = 0x00 // @1BDD stack[1] = 0x1be7 // @1BE0 stack[2] = 0x29 // @1BE2 stack[3] = stack[-1] // } // Block ends with call to 0x1e4d, returns to 0x1BE7 label_1BE7: // Incoming return from call to 0x1E4D at 0x1BE6 // Inputs[2] // { // @1BE8 stack[-1] // @1BE8 stack[-3] // } 1BE7 5B JUMPDEST 1BE8 91 SWAP2 1BE9 50 POP 1BEA 61 PUSH2 0x1bf2 1BED 82 DUP3 1BEE 61 PUSH2 0x243c 1BF1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1BE8 stack[-3] = stack[-1] // @1BEA stack[-1] = 0x1bf2 // @1BED stack[0] = stack[-1] // } // Block ends with call to 0x243c, returns to 0x1BF2 label_1BF2: // Incoming return from call to 0x243C at 0x1BF1 // Inputs[3] // { // @1BF5 stack[-2] // @1BF7 stack[-1] // @1BF9 stack[-3] // } 1BF2 5B JUMPDEST 1BF3 60 PUSH1 0x40 1BF5 82 DUP3 1BF6 01 ADD 1BF7 90 SWAP1 1BF8 50 POP 1BF9 91 SWAP2 1BFA 90 SWAP1 1BFB 50 POP 1BFC 56 *JUMP // Stack delta = -2 // Outputs[1] { @1BF9 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1BFD: // Incoming call from 0x1DF9, returns to 0x1DFA // Inputs[1] { @1C05 stack[-1] } 1BFD 5B JUMPDEST 1BFE 60 PUSH1 0x00 1C00 61 PUSH2 0x1c0a 1C03 60 PUSH1 0x33 1C05 83 DUP4 1C06 61 PUSH2 0x1e4d 1C09 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BFE stack[0] = 0x00 // @1C00 stack[1] = 0x1c0a // @1C03 stack[2] = 0x33 // @1C05 stack[3] = stack[-1] // } // Block ends with call to 0x1e4d, returns to 0x1C0A label_1C0A: // Incoming return from call to 0x1E4D at 0x1C09 // Inputs[2] // { // @1C0B stack[-1] // @1C0B stack[-3] // } 1C0A 5B JUMPDEST 1C0B 91 SWAP2 1C0C 50 POP 1C0D 61 PUSH2 0x1c15 1C10 82 DUP3 1C11 61 PUSH2 0x248b 1C14 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1C0B stack[-3] = stack[-1] // @1C0D stack[-1] = 0x1c15 // @1C10 stack[0] = stack[-1] // } // Block ends with call to 0x248b, returns to 0x1C15 label_1C15: // Incoming return from call to 0x248B at 0x1C14 // Inputs[3] // { // @1C18 stack[-2] // @1C1A stack[-1] // @1C1C stack[-3] // } 1C15 5B JUMPDEST 1C16 60 PUSH1 0x40 1C18 82 DUP3 1C19 01 ADD 1C1A 90 SWAP1 1C1B 50 POP 1C1C 91 SWAP2 1C1D 90 SWAP1 1C1E 50 POP 1C1F 56 *JUMP // Stack delta = -2 // Outputs[1] { @1C1C stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1C20: // Incoming call from 0x1E15, returns to 0x1E16 // Inputs[1] { @1C24 stack[-1] } 1C20 5B JUMPDEST 1C21 61 PUSH2 0x1c29 1C24 81 DUP2 1C25 61 PUSH2 0x20f1 1C28 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C21 stack[0] = 0x1c29 // @1C24 stack[1] = stack[-1] // } // Block ends with call to 0x20f1, returns to 0x1C29 label_1C29: // Incoming return from call to 0x20F1 at 0x1C28 // Inputs[3] // { // @1C2A stack[-3] // @1C2B stack[-1] // @1C2E stack[-4] // } 1C29 5B JUMPDEST 1C2A 82 DUP3 1C2B 52 MSTORE 1C2C 50 POP 1C2D 50 POP 1C2E 56 *JUMP // Stack delta = -4 // Outputs[1] { @1C2B memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1C2F: // Incoming call from 0x1E30, returns to 0x1E31 // Inputs[1] { @1C33 stack[-1] } 1C2F 5B JUMPDEST 1C30 61 PUSH2 0x1c38 1C33 81 DUP2 1C34 61 PUSH2 0x20fb 1C37 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C30 stack[0] = 0x1c38 // @1C33 stack[1] = stack[-1] // } // Block ends with call to 0x20fb, returns to 0x1C38 label_1C38: // Incoming return from call to 0x20FB at 0x1C37 // Inputs[3] // { // @1C39 stack[-3] // @1C3A stack[-1] // @1C3D stack[-4] // } 1C38 5B JUMPDEST 1C39 82 DUP3 1C3A 52 MSTORE 1C3B 50 POP 1C3C 50 POP 1C3D 56 *JUMP // Stack delta = -4 // Outputs[1] { @1C3A memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1C3E: // Incoming call from 0x0178, returns to 0x0179 // Inputs[1] { @1C44 stack[-1] } 1C3E 5B JUMPDEST 1C3F 60 PUSH1 0x00 1C41 61 PUSH2 0x1c49 1C44 82 DUP3 1C45 61 PUSH2 0x1b71 1C48 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C3F stack[0] = 0x00 // @1C41 stack[1] = 0x1c49 // @1C44 stack[2] = stack[-1] // } // Block ends with call to 0x1b71, returns to 0x1C49 label_1C49: // Incoming return from call to 0x1B71 at 0x1C48 // Inputs[4] // { // @1C4A stack[-3] // @1C4A stack[-1] // @1C4D stack[-2] // @1C4F stack[-4] // } 1C49 5B JUMPDEST 1C4A 91 SWAP2 1C4B 50 POP 1C4C 81 DUP2 1C4D 90 SWAP1 1C4E 50 POP 1C4F 91 SWAP2 1C50 90 SWAP1 1C51 50 POP 1C52 56 *JUMP // Stack delta = -3 // Outputs[1] { @1C4F stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1C53: // Incoming call from 0x04E9, returns to 0x04EA // Incoming call from 0x01E6, returns to 0x01E7 // Incoming call from 0x05D0, returns to 0x05D1 // Incoming call from 0x0386, returns to 0x0387 // Incoming call from 0x03EE, returns to 0x03EF // Incoming call from 0x0419, returns to 0x041A // Incoming call from 0x0223, returns to 0x0224 // Inputs[2] // { // @1C58 stack[-1] // @1C63 stack[-2] // } 1C53 5B JUMPDEST 1C54 60 PUSH1 0x00 1C56 60 PUSH1 0x20 1C58 82 DUP3 1C59 01 ADD 1C5A 90 SWAP1 1C5B 50 POP 1C5C 61 PUSH2 0x1c68 1C5F 60 PUSH1 0x00 1C61 83 DUP4 1C62 01 ADD 1C63 84 DUP5 1C64 61 PUSH2 0x1a4d 1C67 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C5A stack[0] = stack[-1] + 0x20 // @1C5C stack[1] = 0x1c68 // @1C62 stack[2] = stack[-1] + 0x00 // @1C63 stack[3] = stack[-2] // } // Block ends with call to 0x1a4d, returns to 0x1C68 label_1C68: // Incoming return from call to 0x1A4D at 0x1C67 // Inputs[3] // { // @1C69 stack[-4] // @1C69 stack[-1] // @1C6A stack[-3] // } 1C68 5B JUMPDEST 1C69 92 SWAP3 1C6A 91 SWAP2 1C6B 50 POP 1C6C 50 POP 1C6D 56 *JUMP // Stack delta = -3 // Outputs[1] { @1C69 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1C6E: // Incoming call from 0x035B, returns to 0x035C // Incoming call from 0x0481, returns to 0x0482 // Incoming call from 0x028B, returns to 0x028C // Incoming call from 0x04BE, returns to 0x04BF // Incoming call from 0x02F3, returns to 0x02F4 // Inputs[2] // { // @1C73 stack[-1] // @1C7E stack[-2] // } 1C6E 5B JUMPDEST 1C6F 60 PUSH1 0x00 1C71 60 PUSH1 0x20 1C73 82 DUP3 1C74 01 ADD 1C75 90 SWAP1 1C76 50 POP 1C77 61 PUSH2 0x1c83 1C7A 60 PUSH1 0x00 1C7C 83 DUP4 1C7D 01 ADD 1C7E 84 DUP5 1C7F 61 PUSH2 0x1a5c 1C82 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C75 stack[0] = stack[-1] + 0x20 // @1C77 stack[1] = 0x1c83 // @1C7D stack[2] = stack[-1] + 0x00 // @1C7E stack[3] = stack[-2] // } // Block ends with call to 0x1a5c, returns to 0x1C83 label_1C83: // Incoming return from call to 0x1A5C at 0x1C82 // Inputs[3] // { // @1C84 stack[-1] // @1C84 stack[-4] // @1C85 stack[-3] // } 1C83 5B JUMPDEST 1C84 92 SWAP3 1C85 91 SWAP2 1C86 50 POP 1C87 50 POP 1C88 56 *JUMP // Stack delta = -3 // Outputs[1] { @1C84 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1C89: // Incoming call from 0x053F, returns to 0x0540 // Inputs[2] // { // @1C8E stack[-1] // @1C99 stack[-2] // } 1C89 5B JUMPDEST 1C8A 60 PUSH1 0x00 1C8C 60 PUSH1 0x20 1C8E 82 DUP3 1C8F 01 ADD 1C90 90 SWAP1 1C91 50 POP 1C92 61 PUSH2 0x1c9e 1C95 60 PUSH1 0x00 1C97 83 DUP4 1C98 01 ADD 1C99 84 DUP5 1C9A 61 PUSH2 0x1a6b 1C9D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C90 stack[0] = stack[-1] + 0x20 // @1C92 stack[1] = 0x1c9e // @1C98 stack[2] = stack[-1] + 0x00 // @1C99 stack[3] = stack[-2] // } // Block ends with call to 0x1a6b, returns to 0x1C9E label_1C9E: // Incoming return from call to 0x1A6B at 0x1C9D // Inputs[3] // { // @1C9F stack[-1] // @1C9F stack[-4] // @1CA0 stack[-3] // } 1C9E 5B JUMPDEST 1C9F 92 SWAP3 1CA0 91 SWAP2 1CA1 50 POP 1CA2 50 POP 1CA3 56 *JUMP // Stack delta = -3 // Outputs[1] { @1C9F stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1CA4: // Incoming call from 0x0514, returns to 0x0515 // Inputs[2] // { // @1CA9 stack[-1] // @1CB4 stack[-2] // } 1CA4 5B JUMPDEST 1CA5 60 PUSH1 0x00 1CA7 60 PUSH1 0x20 1CA9 82 DUP3 1CAA 01 ADD 1CAB 90 SWAP1 1CAC 50 POP 1CAD 61 PUSH2 0x1cb9 1CB0 60 PUSH1 0x00 1CB2 83 DUP4 1CB3 01 ADD 1CB4 84 DUP5 1CB5 61 PUSH2 0x1a7a 1CB8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CAB stack[0] = stack[-1] + 0x20 // @1CAD stack[1] = 0x1cb9 // @1CB3 stack[2] = stack[-1] + 0x00 // @1CB4 stack[3] = stack[-2] // } // Block ends with call to 0x1a7a, returns to 0x1CB9 label_1CB9: // Incoming return from call to 0x1A7A at 0x1CB8 // Inputs[3] // { // @1CBA stack[-1] // @1CBA stack[-4] // @1CBB stack[-3] // } 1CB9 5B JUMPDEST 1CBA 92 SWAP3 1CBB 91 SWAP2 1CBC 50 POP 1CBD 50 POP 1CBE 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CBA stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1CBF: // Incoming call from 0x024E, returns to 0x024F // Incoming call from 0x0444, returns to 0x0445 // Inputs[2] // { // @1CC4 stack[-1] // @1CD4 stack[-2] // } 1CBF 5B JUMPDEST 1CC0 60 PUSH1 0x00 1CC2 60 PUSH1 0x20 1CC4 82 DUP3 1CC5 01 ADD 1CC6 90 SWAP1 1CC7 50 POP 1CC8 81 DUP2 1CC9 81 DUP2 1CCA 03 SUB 1CCB 60 PUSH1 0x00 1CCD 83 DUP4 1CCE 01 ADD 1CCF 52 MSTORE 1CD0 61 PUSH2 0x1cd9 1CD3 81 DUP2 1CD4 84 DUP5 1CD5 61 PUSH2 0x1a89 1CD8 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1CC6 stack[0] = stack[-1] + 0x20 // @1CCF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1CD0 stack[1] = 0x1cd9 // @1CD3 stack[2] = stack[-1] + 0x20 // @1CD4 stack[3] = stack[-2] // } // Block ends with call to 0x1a89, returns to 0x1CD9 label_1CD9: // Incoming return from call to 0x1A89 at 0x1CD8 // Inputs[4] // { // @1CDA stack[-2] // @1CDA stack[-1] // @1CDC stack[-5] // @1CDD stack[-4] // } 1CD9 5B JUMPDEST 1CDA 90 SWAP1 1CDB 50 POP 1CDC 92 SWAP3 1CDD 91 SWAP2 1CDE 50 POP 1CDF 50 POP 1CE0 56 *JUMP // Stack delta = -4 // Outputs[1] { @1CDC stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1CE1: // Incoming call from 0x1477, returns to 0x1478 // Inputs[1] { @1CE6 stack[-1] } 1CE1 5B JUMPDEST 1CE2 60 PUSH1 0x00 1CE4 60 PUSH1 0x20 1CE6 82 DUP3 1CE7 01 ADD 1CE8 90 SWAP1 1CE9 50 POP 1CEA 81 DUP2 1CEB 81 DUP2 1CEC 03 SUB 1CED 60 PUSH1 0x00 1CEF 83 DUP4 1CF0 01 ADD 1CF1 52 MSTORE 1CF2 61 PUSH2 0x1cfa 1CF5 81 DUP2 1CF6 61 PUSH2 0x1ac2 1CF9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1CE8 stack[0] = stack[-1] + 0x20 // @1CF1 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1CF2 stack[1] = 0x1cfa // @1CF5 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1ac2, returns to 0x1CFA label_1CFA: // Incoming return from call to 0x1AC2 at 0x1CF9 // Inputs[4] // { // @1CFB stack[-1] // @1CFB stack[-2] // @1CFD stack[-4] // @1CFE stack[-3] // } 1CFA 5B JUMPDEST 1CFB 90 SWAP1 1CFC 50 POP 1CFD 91 SWAP2 1CFE 90 SWAP1 1CFF 50 POP 1D00 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CFD stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1D01: // Incoming call from 0x0D79, returns to 0x0D7A // Inputs[1] { @1D06 stack[-1] } 1D01 5B JUMPDEST 1D02 60 PUSH1 0x00 1D04 60 PUSH1 0x20 1D06 82 DUP3 1D07 01 ADD 1D08 90 SWAP1 1D09 50 POP 1D0A 81 DUP2 1D0B 81 DUP2 1D0C 03 SUB 1D0D 60 PUSH1 0x00 1D0F 83 DUP4 1D10 01 ADD 1D11 52 MSTORE 1D12 61 PUSH2 0x1d1a 1D15 81 DUP2 1D16 61 PUSH2 0x1ae5 1D19 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1D08 stack[0] = stack[-1] + 0x20 // @1D11 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1D12 stack[1] = 0x1d1a // @1D15 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1ae5, returns to 0x1D1A label_1D1A: // Incoming return from call to 0x1AE5 at 0x1D19 // Inputs[4] // { // @1D1B stack[-2] // @1D1B stack[-1] // @1D1D stack[-4] // @1D1E stack[-3] // } 1D1A 5B JUMPDEST 1D1B 90 SWAP1 1D1C 50 POP 1D1D 91 SWAP2 1D1E 90 SWAP1 1D1F 50 POP 1D20 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D1D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1D21: // Incoming call from 0x131C, returns to 0x131D // Inputs[1] { @1D26 stack[-1] } 1D21 5B JUMPDEST 1D22 60 PUSH1 0x00 1D24 60 PUSH1 0x20 1D26 82 DUP3 1D27 01 ADD 1D28 90 SWAP1 1D29 50 POP 1D2A 81 DUP2 1D2B 81 DUP2 1D2C 03 SUB 1D2D 60 PUSH1 0x00 1D2F 83 DUP4 1D30 01 ADD 1D31 52 MSTORE 1D32 61 PUSH2 0x1d3a 1D35 81 DUP2 1D36 61 PUSH2 0x1b08 1D39 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1D28 stack[0] = stack[-1] + 0x20 // @1D31 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1D32 stack[1] = 0x1d3a // @1D35 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1b08, returns to 0x1D3A label_1D3A: // Incoming return from call to 0x1B08 at 0x1D39 // Inputs[4] // { // @1D3B stack[-2] // @1D3B stack[-1] // @1D3D stack[-4] // @1D3E stack[-3] // } 1D3A 5B JUMPDEST 1D3B 90 SWAP1 1D3C 50 POP 1D3D 91 SWAP2 1D3E 90 SWAP1 1D3F 50 POP 1D40 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D3D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1D41: // Incoming call from 0x0F36, returns to 0x0F37 // Inputs[1] { @1D46 stack[-1] } 1D41 5B JUMPDEST 1D42 60 PUSH1 0x00 1D44 60 PUSH1 0x20 1D46 82 DUP3 1D47 01 ADD 1D48 90 SWAP1 1D49 50 POP 1D4A 81 DUP2 1D4B 81 DUP2 1D4C 03 SUB 1D4D 60 PUSH1 0x00 1D4F 83 DUP4 1D50 01 ADD 1D51 52 MSTORE 1D52 61 PUSH2 0x1d5a 1D55 81 DUP2 1D56 61 PUSH2 0x1b2b 1D59 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1D48 stack[0] = stack[-1] + 0x20 // @1D51 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1D52 stack[1] = 0x1d5a // @1D55 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1b2b, returns to 0x1D5A label_1D5A: // Incoming return from call to 0x1B2B at 0x1D59 // Inputs[4] // { // @1D5B stack[-1] // @1D5B stack[-2] // @1D5D stack[-4] // @1D5E stack[-3] // } 1D5A 5B JUMPDEST 1D5B 90 SWAP1 1D5C 50 POP 1D5D 91 SWAP2 1D5E 90 SWAP1 1D5F 50 POP 1D60 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D5D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1D61: // Incoming call from 0x14E7, returns to 0x14E8 // Inputs[1] { @1D66 stack[-1] } 1D61 5B JUMPDEST 1D62 60 PUSH1 0x00 1D64 60 PUSH1 0x20 1D66 82 DUP3 1D67 01 ADD 1D68 90 SWAP1 1D69 50 POP 1D6A 81 DUP2 1D6B 81 DUP2 1D6C 03 SUB 1D6D 60 PUSH1 0x00 1D6F 83 DUP4 1D70 01 ADD 1D71 52 MSTORE 1D72 61 PUSH2 0x1d7a 1D75 81 DUP2 1D76 61 PUSH2 0x1b4e 1D79 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1D68 stack[0] = stack[-1] + 0x20 // @1D71 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1D72 stack[1] = 0x1d7a // @1D75 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1b4e, returns to 0x1D7A label_1D7A: // Incoming return from call to 0x1B4E at 0x1D79 // Inputs[4] // { // @1D7B stack[-2] // @1D7B stack[-1] // @1D7D stack[-4] // @1D7E stack[-3] // } 1D7A 5B JUMPDEST 1D7B 90 SWAP1 1D7C 50 POP 1D7D 91 SWAP2 1D7E 90 SWAP1 1D7F 50 POP 1D80 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D7D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1D81: // Incoming call from 0x12AC, returns to 0x12AD // Inputs[1] { @1D86 stack[-1] } 1D81 5B JUMPDEST 1D82 60 PUSH1 0x00 1D84 60 PUSH1 0x20 1D86 82 DUP3 1D87 01 ADD 1D88 90 SWAP1 1D89 50 POP 1D8A 81 DUP2 1D8B 81 DUP2 1D8C 03 SUB 1D8D 60 PUSH1 0x00 1D8F 83 DUP4 1D90 01 ADD 1D91 52 MSTORE 1D92 61 PUSH2 0x1d9a 1D95 81 DUP2 1D96 61 PUSH2 0x1b94 1D99 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1D88 stack[0] = stack[-1] + 0x20 // @1D91 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1D92 stack[1] = 0x1d9a // @1D95 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1b94, returns to 0x1D9A label_1D9A: // Incoming return from call to 0x1B94 at 0x1D99 // Inputs[4] // { // @1D9B stack[-1] // @1D9B stack[-2] // @1D9D stack[-4] // @1D9E stack[-3] // } 1D9A 5B JUMPDEST 1D9B 90 SWAP1 1D9C 50 POP 1D9D 91 SWAP2 1D9E 90 SWAP1 1D9F 50 POP 1DA0 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D9D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1DA1: // Incoming call from 0x152A, returns to 0x152B // Inputs[1] { @1DA6 stack[-1] } 1DA1 5B JUMPDEST 1DA2 60 PUSH1 0x00 1DA4 60 PUSH1 0x20 1DA6 82 DUP3 1DA7 01 ADD 1DA8 90 SWAP1 1DA9 50 POP 1DAA 81 DUP2 1DAB 81 DUP2 1DAC 03 SUB 1DAD 60 PUSH1 0x00 1DAF 83 DUP4 1DB0 01 ADD 1DB1 52 MSTORE 1DB2 61 PUSH2 0x1dba 1DB5 81 DUP2 1DB6 61 PUSH2 0x1bb7 1DB9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1DA8 stack[0] = stack[-1] + 0x20 // @1DB1 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1DB2 stack[1] = 0x1dba // @1DB5 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1bb7, returns to 0x1DBA label_1DBA: // Incoming return from call to 0x1BB7 at 0x1DB9 // Inputs[4] // { // @1DBB stack[-2] // @1DBB stack[-1] // @1DBD stack[-4] // @1DBE stack[-3] // } 1DBA 5B JUMPDEST 1DBB 90 SWAP1 1DBC 50 POP 1DBD 91 SWAP2 1DBE 90 SWAP1 1DBF 50 POP 1DC0 56 *JUMP // Stack delta = -3 // Outputs[1] { @1DBD stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1DC1: // Incoming call from 0x0A8C, returns to 0x0A8D // Inputs[1] { @1DC6 stack[-1] } 1DC1 5B JUMPDEST 1DC2 60 PUSH1 0x00 1DC4 60 PUSH1 0x20 1DC6 82 DUP3 1DC7 01 ADD 1DC8 90 SWAP1 1DC9 50 POP 1DCA 81 DUP2 1DCB 81 DUP2 1DCC 03 SUB 1DCD 60 PUSH1 0x00 1DCF 83 DUP4 1DD0 01 ADD 1DD1 52 MSTORE 1DD2 61 PUSH2 0x1dda 1DD5 81 DUP2 1DD6 61 PUSH2 0x1bda 1DD9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1DC8 stack[0] = stack[-1] + 0x20 // @1DD1 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1DD2 stack[1] = 0x1dda // @1DD5 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1bda, returns to 0x1DDA label_1DDA: // Incoming return from call to 0x1BDA at 0x1DD9 // Inputs[4] // { // @1DDB stack[-2] // @1DDB stack[-1] // @1DDD stack[-4] // @1DDE stack[-3] // } 1DDA 5B JUMPDEST 1DDB 90 SWAP1 1DDC 50 POP 1DDD 91 SWAP2 1DDE 90 SWAP1 1DDF 50 POP 1DE0 56 *JUMP // Stack delta = -3 // Outputs[1] { @1DDD stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1DE1: // Incoming call from 0x1750, returns to 0x1751 // Inputs[1] { @1DE6 stack[-1] } 1DE1 5B JUMPDEST 1DE2 60 PUSH1 0x00 1DE4 60 PUSH1 0x20 1DE6 82 DUP3 1DE7 01 ADD 1DE8 90 SWAP1 1DE9 50 POP 1DEA 81 DUP2 1DEB 81 DUP2 1DEC 03 SUB 1DED 60 PUSH1 0x00 1DEF 83 DUP4 1DF0 01 ADD 1DF1 52 MSTORE 1DF2 61 PUSH2 0x1dfa 1DF5 81 DUP2 1DF6 61 PUSH2 0x1bfd 1DF9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1DE8 stack[0] = stack[-1] + 0x20 // @1DF1 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1DF2 stack[1] = 0x1dfa // @1DF5 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1bfd, returns to 0x1DFA label_1DFA: // Incoming return from call to 0x1BFD at 0x1DF9 // Inputs[4] // { // @1DFB stack[-2] // @1DFB stack[-1] // @1DFD stack[-4] // @1DFE stack[-3] // } 1DFA 5B JUMPDEST 1DFB 90 SWAP1 1DFC 50 POP 1DFD 91 SWAP2 1DFE 90 SWAP1 1DFF 50 POP 1E00 56 *JUMP // Stack delta = -3 // Outputs[1] { @1DFD stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1E01: // Incoming call from 0x02B6, returns to 0x02B7 // Incoming call from 0x1403, returns to 0x1404 // Incoming call from 0x057C, returns to 0x057D // Incoming call from 0x18D2, returns to 0x18D3 // Incoming call from 0x03C3, returns to 0x03C4 // Inputs[2] // { // @1E06 stack[-1] // @1E11 stack[-2] // } 1E01 5B JUMPDEST 1E02 60 PUSH1 0x00 1E04 60 PUSH1 0x20 1E06 82 DUP3 1E07 01 ADD 1E08 90 SWAP1 1E09 50 POP 1E0A 61 PUSH2 0x1e16 1E0D 60 PUSH1 0x00 1E0F 83 DUP4 1E10 01 ADD 1E11 84 DUP5 1E12 61 PUSH2 0x1c20 1E15 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E08 stack[0] = stack[-1] + 0x20 // @1E0A stack[1] = 0x1e16 // @1E10 stack[2] = stack[-1] + 0x00 // @1E11 stack[3] = stack[-2] // } // Block ends with call to 0x1c20, returns to 0x1E16 label_1E16: // Incoming return from call to 0x1C20 at 0x1E15 // Inputs[3] // { // @1E17 stack[-4] // @1E17 stack[-1] // @1E18 stack[-3] // } 1E16 5B JUMPDEST 1E17 92 SWAP3 1E18 91 SWAP2 1E19 50 POP 1E1A 50 POP 1E1B 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E17 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1E1C: // Incoming call from 0x031E, returns to 0x031F // Inputs[2] // { // @1E21 stack[-1] // @1E2C stack[-2] // } 1E1C 5B JUMPDEST 1E1D 60 PUSH1 0x00 1E1F 60 PUSH1 0x20 1E21 82 DUP3 1E22 01 ADD 1E23 90 SWAP1 1E24 50 POP 1E25 61 PUSH2 0x1e31 1E28 60 PUSH1 0x00 1E2A 83 DUP4 1E2B 01 ADD 1E2C 84 DUP5 1E2D 61 PUSH2 0x1c2f 1E30 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E23 stack[0] = stack[-1] + 0x20 // @1E25 stack[1] = 0x1e31 // @1E2B stack[2] = stack[-1] + 0x00 // @1E2C stack[3] = stack[-2] // } // Block ends with call to 0x1c2f, returns to 0x1E31 label_1E31: // Incoming return from call to 0x1C2F at 0x1E30 // Inputs[3] // { // @1E32 stack[-4] // @1E32 stack[-1] // @1E33 stack[-3] // } 1E31 5B JUMPDEST 1E32 92 SWAP3 1E33 91 SWAP2 1E34 50 POP 1E35 50 POP 1E36 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E32 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1E37: // Incoming call from 0x1A93, returns to 0x1A94 // Inputs[3] // { // @1E3A stack[-1] // @1E3B memory[stack[-1]:stack[-1] + 0x20] // @1E3E stack[-2] // } 1E37 5B JUMPDEST 1E38 60 PUSH1 0x00 1E3A 81 DUP2 1E3B 51 MLOAD 1E3C 90 SWAP1 1E3D 50 POP 1E3E 91 SWAP2 1E3F 90 SWAP1 1E40 50 POP 1E41 56 *JUMP // Stack delta = -1 // Outputs[1] { @1E3E stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_1E42: // Incoming call from 0x1B7D, returns to 0x1B7E // Inputs[3] // { // @1E45 stack[-1] // @1E48 stack[-3] // @1E49 stack[-2] // } 1E42 5B JUMPDEST 1E43 60 PUSH1 0x00 1E45 81 DUP2 1E46 90 SWAP1 1E47 50 POP 1E48 92 SWAP3 1E49 91 SWAP2 1E4A 50 POP 1E4B 50 POP 1E4C 56 *JUMP // Stack delta = -2 // Outputs[1] { @1E48 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1E4D: // Incoming call from 0x1B14, returns to 0x1B15 // Incoming call from 0x1BE6, returns to 0x1BE7 // Incoming call from 0x1BC3, returns to 0x1BC4 // Incoming call from 0x1BA0, returns to 0x1BA1 // Incoming call from 0x1A9D, returns to 0x1A9E // Incoming call from 0x1C09, returns to 0x1C0A // Incoming call from 0x1B37, returns to 0x1B38 // Incoming call from 0x1AF1, returns to 0x1AF2 // Incoming call from 0x1ACE, returns to 0x1ACF // Incoming call from 0x1B5A, returns to 0x1B5B // Inputs[3] // { // @1E50 stack[-2] // @1E51 stack[-1] // @1E59 stack[-3] // } 1E4D 5B JUMPDEST 1E4E 60 PUSH1 0x00 1E50 82 DUP3 1E51 82 DUP3 1E52 52 MSTORE 1E53 60 PUSH1 0x20 1E55 82 DUP3 1E56 01 ADD 1E57 90 SWAP1 1E58 50 POP 1E59 92 SWAP3 1E5A 91 SWAP2 1E5B 50 POP 1E5C 50 POP 1E5D 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1E52 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1E59 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_1E5E: // Incoming call from 0x1832, returns to 0x1833 // Incoming call from 0x0B60, returns to 0x0B61 // Inputs[1] { @1E64 stack[-1] } 1E5E 5B JUMPDEST 1E5F 60 PUSH1 0x00 1E61 61 PUSH2 0x1e69 1E64 82 DUP3 1E65 61 PUSH2 0x20f1 1E68 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E5F stack[0] = 0x00 // @1E61 stack[1] = 0x1e69 // @1E64 stack[2] = stack[-1] // } // Block ends with call to 0x20f1, returns to 0x1E69 label_1E69: // Incoming return from call to 0x20F1 at 0x1E68 // Inputs[3] // { // @1E6A stack[-3] // @1E6A stack[-1] // @1E6F stack[-4] // } 1E69 5B JUMPDEST 1E6A 91 SWAP2 1E6B 50 POP 1E6C 61 PUSH2 0x1e74 1E6F 83 DUP4 1E70 61 PUSH2 0x20f1 1E73 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1E6A stack[-3] = stack[-1] // @1E6C stack[-1] = 0x1e74 // @1E6F stack[0] = stack[-4] // } // Block ends with call to 0x20f1, returns to 0x1E74 label_1E74: // Incoming return from call to 0x20F1 at 0x1E73 // Inputs[3] // { // @1E75 stack[-4] // @1E75 stack[-1] // @1E9A stack[-3] // } 1E74 5B JUMPDEST 1E75 92 SWAP3 1E76 50 POP 1E77 82 DUP3 1E78 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1E99 03 SUB 1E9A 82 DUP3 1E9B 11 GT 1E9C 15 ISZERO 1E9D 61 PUSH2 0x1ea9 1EA0 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1E75 stack[-4] = stack[-1] } // Block ends with conditional jump to 0x1ea9, if !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) label_1EA1: // Incoming jump from 0x1EA0, if not !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) 1EA1 61 PUSH2 0x1ea8 1EA4 61 PUSH2 0x21b5 1EA7 56 *JUMP // Stack delta = +1 // Outputs[1] { @1EA1 stack[0] = 0x1ea8 } // Block ends with unconditional jump to 0x21b5 1EA8 5B JUMPDEST label_1EA9: // Incoming jump from 0x1EA0, if !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) // Inputs[4] // { // @1EAA stack[-3] // @1EAB stack[-2] // @1EAD stack[-1] // @1EAF stack[-4] // } 1EA9 5B JUMPDEST 1EAA 82 DUP3 1EAB 82 DUP3 1EAC 01 ADD 1EAD 90 SWAP1 1EAE 50 POP 1EAF 92 SWAP3 1EB0 91 SWAP2 1EB1 50 POP 1EB2 50 POP 1EB3 56 *JUMP // Stack delta = -3 // Outputs[1] { @1EAF stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_1EB4: // Incoming call from 0x2000, returns to 0x2001 // Inputs[3] // { // @1EB8 stack[-1] // @1EBB stack[-2] // @1EC1 stack[-3] // } 1EB4 5B JUMPDEST 1EB5 60 PUSH1 0x00 1EB7 80 DUP1 1EB8 82 DUP3 1EB9 91 SWAP2 1EBA 50 POP 1EBB 83 DUP4 1EBC 90 SWAP1 1EBD 50 POP 1EBE 5B JUMPDEST 1EBF 60 PUSH1 0x01 1EC1 85 DUP6 1EC2 11 GT 1EC3 15 ISZERO 1EC4 61 PUSH2 0x1efe 1EC7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1EB9 stack[0] = stack[-1] // @1EBC stack[1] = stack[-2] // } // Block ends with conditional jump to 0x1efe, if !(stack[-3] > 0x01) label_1EC8: // Incoming jump from 0x1EC7, if not !(stack[-5] > 0x01) // Incoming jump from 0x1EC7, if not !(stack[-3] > 0x01) // Inputs[2] // { // @1EC8 stack[-1] // @1EC9 stack[-6] // } 1EC8 80 DUP1 1EC9 86 DUP7 1ECA 04 DIV 1ECB 81 DUP2 1ECC 11 GT 1ECD 15 ISZERO 1ECE 61 PUSH2 0x1eda 1ED1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1eda, if !(stack[-1] > stack[-6] / stack[-1]) label_1ED2: // Incoming jump from 0x1ED1, if not !(stack[-1] > stack[-6] / stack[-1]) 1ED2 61 PUSH2 0x1ed9 1ED5 61 PUSH2 0x21b5 1ED8 56 *JUMP // Stack delta = +1 // Outputs[1] { @1ED2 stack[0] = 0x1ed9 } // Block ends with unconditional jump to 0x21b5 1ED9 5B JUMPDEST label_1EDA: // Incoming jump from 0x1ED1, if !(stack[-1] > stack[-6] / stack[-1]) // Inputs[1] { @1EDD stack[-5] } 1EDA 5B JUMPDEST 1EDB 60 PUSH1 0x01 1EDD 85 DUP6 1EDE 16 AND 1EDF 15 ISZERO 1EE0 61 PUSH2 0x1ee9 1EE3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ee9, if !(stack[-5] & 0x01) label_1EE4: // Incoming jump from 0x1EE3, if not !(stack[-5] & 0x01) // Inputs[3] // { // @1EE4 stack[-1] // @1EE5 stack[-2] // @1EF2 stack[-5] // } 1EE4 80 DUP1 1EE5 82 DUP3 1EE6 02 MUL 1EE7 91 SWAP2 1EE8 50 POP 1EE9 5B JUMPDEST 1EEA 80 DUP1 1EEB 81 DUP2 1EEC 02 MUL 1EED 90 SWAP1 1EEE 50 POP 1EEF 61 PUSH2 0x1ef7 1EF2 85 DUP6 1EF3 61 PUSH2 0x2229 1EF6 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1EE7 stack[-2] = stack[-2] * stack[-1] // @1EED stack[-1] = stack[-1] * stack[-1] // @1EEF stack[0] = 0x1ef7 // @1EF2 stack[1] = stack[-5] // } // Block ends with call to 0x2229, returns to 0x1EF7 label_1EF7: // Incoming return from call to 0x2229 at 0x1EF6 // Incoming return from call to 0x2229 at 0x1EF6 // Inputs[2] // { // @1EF8 stack[-1] // @1EF8 stack[-6] // } 1EF7 5B JUMPDEST 1EF8 94 SWAP5 1EF9 50 POP 1EFA 61 PUSH2 0x1ebe 1EFD 56 *JUMP // Stack delta = -1 // Outputs[1] { @1EF8 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x1ebe label_1EFE: // Incoming jump from 0x1EC7, if !(stack[-5] > 0x01) // Incoming jump from 0x1EC7, if !(stack[-3] > 0x01) // Inputs[5] // { // @1EFF stack[-6] // @1EFF stack[-1] // @1F01 stack[-2] // @1F01 stack[-7] // @1F02 stack[-5] // } 1EFE 5B JUMPDEST 1EFF 94 SWAP5 1F00 50 POP 1F01 94 SWAP5 1F02 92 SWAP3 1F03 50 POP 1F04 50 POP 1F05 50 POP 1F06 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1EFF stack[-6] = stack[-1] // @1F01 stack[-7] = stack[-2] // } // Block ends with unconditional jump to stack[-7] label_1F07: // Incoming call from 0x09AA, returns to 0x09AB // Inputs[1] { @1F0D stack[-1] } 1F07 5B JUMPDEST 1F08 60 PUSH1 0x00 1F0A 61 PUSH2 0x1f12 1F0D 82 DUP3 1F0E 61 PUSH2 0x20f1 1F11 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F08 stack[0] = 0x00 // @1F0A stack[1] = 0x1f12 // @1F0D stack[2] = stack[-1] // } // Block ends with call to 0x20f1, returns to 0x1F12 label_1F12: // Incoming return from call to 0x20F1 at 0x1F11 // Inputs[3] // { // @1F13 stack[-3] // @1F13 stack[-1] // @1F18 stack[-4] // } 1F12 5B JUMPDEST 1F13 91 SWAP2 1F14 50 POP 1F15 61 PUSH2 0x1f1d 1F18 83 DUP4 1F19 61 PUSH2 0x20fb 1F1C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1F13 stack[-3] = stack[-1] // @1F15 stack[-1] = 0x1f1d // @1F18 stack[0] = stack[-4] // } // Block ends with call to 0x20fb, returns to 0x1F1D label_1F1D: // Incoming return from call to 0x20FB at 0x1F1C // Inputs[3] // { // @1F1E stack[-1] // @1F1E stack[-4] // @1F45 stack[-3] // } 1F1D 5B JUMPDEST 1F1E 92 SWAP3 1F1F 50 POP 1F20 61 PUSH2 0x1f4a 1F23 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1F44 84 DUP5 1F45 84 DUP5 1F46 61 PUSH2 0x1f52 1F49 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1F1E stack[-4] = stack[-1] // @1F20 stack[-1] = 0x1f4a // @1F23 stack[0] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // @1F44 stack[1] = stack[-1] // @1F45 stack[2] = stack[-3] // } // Block ends with call to 0x1f52, returns to 0x1F4A label_1F4A: // Incoming return from call to 0x1F52 at 0x1F49 // Inputs[4] // { // @1F4B stack[-2] // @1F4B stack[-1] // @1F4D stack[-5] // @1F4E stack[-4] // } 1F4A 5B JUMPDEST 1F4B 90 SWAP1 1F4C 50 POP 1F4D 92 SWAP3 1F4E 91 SWAP2 1F4F 50 POP 1F50 50 POP 1F51 56 *JUMP // Stack delta = -4 // Outputs[1] { @1F4D stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1F52: // Incoming call from 0x1F49, returns to 0x1F4A // Inputs[1] { @1F55 stack[-2] } 1F52 5B JUMPDEST 1F53 60 PUSH1 0x00 1F55 82 DUP3 1F56 61 PUSH2 0x1f62 1F59 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F53 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f62, if stack[-2] label_1F5A: // Incoming jump from 0x1F59, if not stack[-2] // Inputs[1] { @1F5C stack[-1] } 1F5A 60 PUSH1 0x01 1F5C 90 SWAP1 1F5D 50 POP 1F5E 61 PUSH2 0x201e 1F61 56 *JUMP // Stack delta = +0 // Outputs[1] { @1F5C stack[-1] = 0x01 } // Block ends with unconditional jump to 0x201e label_1F62: // Incoming jump from 0x1F59, if stack[-2] // Inputs[1] { @1F63 stack[-2] } 1F62 5B JUMPDEST 1F63 81 DUP2 1F64 61 PUSH2 0x1f70 1F67 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f70, if stack[-2] label_1F68: // Incoming jump from 0x1F67, if not stack[-2] // Inputs[1] { @1F6A stack[-1] } 1F68 60 PUSH1 0x00 1F6A 90 SWAP1 1F6B 50 POP 1F6C 61 PUSH2 0x201e 1F6F 56 *JUMP // Stack delta = +0 // Outputs[1] { @1F6A stack[-1] = 0x00 } // Block ends with unconditional jump to 0x201e label_1F70: // Incoming jump from 0x1F67, if stack[-2] // Inputs[1] { @1F71 stack[-2] } 1F70 5B JUMPDEST 1F71 81 DUP2 1F72 60 PUSH1 0x01 1F74 81 DUP2 1F75 14 EQ 1F76 61 PUSH2 0x1f86 1F79 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F71 stack[0] = stack[-2] } // Block ends with conditional jump to 0x1f86, if stack[-2] == 0x01 label_1F7A: // Incoming jump from 0x1F79, if not stack[-2] == 0x01 // Inputs[1] { @1F7C stack[-1] } 1F7A 60 PUSH1 0x02 1F7C 81 DUP2 1F7D 14 EQ 1F7E 61 PUSH2 0x1f90 1F81 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f90, if stack[-1] == 0x02 label_1F82: // Incoming jump from 0x1F81, if not stack[-1] == 0x02 1F82 61 PUSH2 0x1fbf 1F85 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1fbf label_1F86: // Incoming jump from 0x1F79, if stack[-2] == 0x01 // Inputs[1] { @1F89 stack[-2] } 1F86 5B JUMPDEST 1F87 60 PUSH1 0x01 1F89 91 SWAP2 1F8A 50 POP 1F8B 50 POP 1F8C 61 PUSH2 0x201e 1F8F 56 *JUMP // Stack delta = -1 // Outputs[1] { @1F89 stack[-2] = 0x01 } // Block ends with unconditional jump to 0x201e label_1F90: // Incoming jump from 0x1F81, if stack[-1] == 0x02 // Inputs[1] { @1F93 stack[-4] } 1F90 5B JUMPDEST 1F91 60 PUSH1 0xff 1F93 84 DUP5 1F94 11 GT 1F95 15 ISZERO 1F96 61 PUSH2 0x1fa2 1F99 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1fa2, if !(stack[-4] > 0xff) label_1F9A: // Incoming jump from 0x1F99, if not !(stack[-4] > 0xff) 1F9A 61 PUSH2 0x1fa1 1F9D 61 PUSH2 0x21b5 1FA0 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F9A stack[0] = 0x1fa1 } // Block ends with unconditional jump to 0x21b5 1FA1 5B JUMPDEST label_1FA2: // Incoming jump from 0x1F99, if !(stack[-4] > 0xff) // Inputs[3] // { // @1FA3 stack[-4] // @1FA7 stack[-2] // @1FA9 stack[-5] // } 1FA2 5B JUMPDEST 1FA3 83 DUP4 1FA4 60 PUSH1 0x02 1FA6 0A EXP 1FA7 91 SWAP2 1FA8 50 POP 1FA9 84 DUP5 1FAA 82 DUP3 1FAB 11 GT 1FAC 15 ISZERO 1FAD 61 PUSH2 0x1fb9 1FB0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1FA7 stack[-2] = 0x02 ** stack[-4] } // Block ends with conditional jump to 0x1fb9, if !(0x02 ** stack[-4] > stack[-5]) label_1FB1: // Incoming jump from 0x1FB0, if not !(0x02 ** stack[-4] > stack[-5]) 1FB1 61 PUSH2 0x1fb8 1FB4 61 PUSH2 0x21b5 1FB7 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FB1 stack[0] = 0x1fb8 } // Block ends with unconditional jump to 0x21b5 1FB8 5B JUMPDEST label_1FB9: // Incoming jump from 0x1FB0, if !(0x02 ** stack[-4] > stack[-5]) 1FB9 5B JUMPDEST 1FBA 50 POP 1FBB 61 PUSH2 0x201e 1FBE 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x201e label_1FBF: // Incoming jump from 0x1F85 // Inputs[2] // { // @1FC3 stack[-4] // @1FC8 stack[-3] // } 1FBF 5B JUMPDEST 1FC0 50 POP 1FC1 60 PUSH1 0x20 1FC3 83 DUP4 1FC4 10 LT 1FC5 61 PUSH2 0x0133 1FC8 83 DUP4 1FC9 10 LT 1FCA 16 AND 1FCB 60 PUSH1 0x4e 1FCD 84 DUP5 1FCE 10 LT 1FCF 60 PUSH1 0x0b 1FD1 84 DUP5 1FD2 10 LT 1FD3 16 AND 1FD4 17 OR 1FD5 15 ISZERO 1FD6 61 PUSH2 0x1ff4 1FD9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1ff4, if !(((stack[-3] < 0x0b) & (stack[-4] < 0x4e)) | ((stack[-3] < 0x0133) & (stack[-4] < 0x20))) label_1FDA: // Incoming jump from 0x1FD9, if not !(((stack[-3] < 0x0b) & (stack[-4] < 0x4e)) | ((stack[-3] < 0x0133) & (stack[-4] < 0x20))) // Inputs[4] // { // @1FDA stack[-3] // @1FDB stack[-2] // @1FDD stack[-1] // @1FDF stack[-4] // } 1FDA 82 DUP3 1FDB 82 DUP3 1FDC 0A EXP 1FDD 90 SWAP1 1FDE 50 POP 1FDF 83 DUP4 1FE0 81 DUP2 1FE1 11 GT 1FE2 15 ISZERO 1FE3 61 PUSH2 0x1fef 1FE6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1FDD stack[-1] = stack[-2] ** stack[-3] } // Block ends with conditional jump to 0x1fef, if !(stack[-2] ** stack[-3] > stack[-4]) label_1FE7: // Incoming jump from 0x1FE6, if not !(stack[-2] ** stack[-3] > stack[-4]) 1FE7 61 PUSH2 0x1fee 1FEA 61 PUSH2 0x21b5 1FED 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FE7 stack[0] = 0x1fee } // Block ends with unconditional jump to 0x21b5 1FEE 5B JUMPDEST label_1FEF: // Incoming jump from 0x1FE6, if !(stack[-2] ** stack[-3] > stack[-4]) 1FEF 5B JUMPDEST 1FF0 61 PUSH2 0x201e 1FF3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x201e label_1FF4: // Incoming jump from 0x1FD9, if !(((stack[-3] < 0x0b) & (stack[-4] < 0x4e)) | ((stack[-3] < 0x0133) & (stack[-4] < 0x20))) // Inputs[3] // { // @1FF8 stack[-4] // @1FF9 stack[-3] // @1FFA stack[-2] // } 1FF4 5B JUMPDEST 1FF5 61 PUSH2 0x2001 1FF8 84 DUP5 1FF9 84 DUP5 1FFA 84 DUP5 1FFB 60 PUSH1 0x01 1FFD 61 PUSH2 0x1eb4 2000 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1FF5 stack[0] = 0x2001 // @1FF8 stack[1] = stack[-4] // @1FF9 stack[2] = stack[-3] // @1FFA stack[3] = stack[-2] // @1FFB stack[4] = 0x01 // } // Block ends with call to 0x1eb4, returns to 0x2001 label_2001: // Incoming return from call to 0x1EB4 at 0x2000 // Inputs[5] // { // @2002 stack[-4] // @2002 stack[-1] // @2004 stack[-2] // @2004 stack[-3] // @2007 stack[-6] // } 2001 5B JUMPDEST 2002 92 SWAP3 2003 50 POP 2004 90 SWAP1 2005 50 POP 2006 81 DUP2 2007 84 DUP5 2008 04 DIV 2009 81 DUP2 200A 11 GT 200B 15 ISZERO 200C 61 PUSH2 0x2018 200F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2002 stack[-4] = stack[-1] // @2004 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x2018, if !(stack[-2] > stack[-6] / stack[-1]) label_2010: // Incoming jump from 0x200F, if not !(stack[-2] > stack[-6] / stack[-1]) 2010 61 PUSH2 0x2017 2013 61 PUSH2 0x21b5 2016 56 *JUMP // Stack delta = +1 // Outputs[1] { @2010 stack[0] = 0x2017 } // Block ends with unconditional jump to 0x21b5 2017 5B JUMPDEST label_2018: // Incoming jump from 0x200F, if !(stack[-2] > stack[-6] / stack[-1]) // Inputs[2] // { // @2019 stack[-2] // @201A stack[-1] // } 2018 5B JUMPDEST 2019 81 DUP2 201A 81 DUP2 201B 02 MUL 201C 90 SWAP1 201D 50 POP // Stack delta = +0 // Outputs[1] { @201C stack[-1] = stack[-1] * stack[-2] } // Block continues label_201E: // Incoming jump from 0x1FBE // Incoming jump from 0x1F6F // Incoming jump from 0x201D // Incoming jump from 0x1FF3 // Incoming jump from 0x1F61 // Incoming jump from 0x1F8F // Inputs[3] // { // @201F stack[-5] // @201F stack[-1] // @2020 stack[-4] // } 201E 5B JUMPDEST 201F 93 SWAP4 2020 92 SWAP3 2021 50 POP 2022 50 POP 2023 50 POP 2024 56 *JUMP // Stack delta = -4 // Outputs[1] { @201F stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2025: // Incoming call from 0x09BA, returns to 0x09BB // Inputs[1] { @202B stack[-1] } 2025 5B JUMPDEST 2026 60 PUSH1 0x00 2028 61 PUSH2 0x2030 202B 82 DUP3 202C 61 PUSH2 0x20f1 202F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2026 stack[0] = 0x00 // @2028 stack[1] = 0x2030 // @202B stack[2] = stack[-1] // } // Block ends with call to 0x20f1, returns to 0x2030 label_2030: // Incoming return from call to 0x20F1 at 0x202F // Inputs[3] // { // @2031 stack[-3] // @2031 stack[-1] // @2036 stack[-4] // } 2030 5B JUMPDEST 2031 91 SWAP2 2032 50 POP 2033 61 PUSH2 0x203b 2036 83 DUP4 2037 61 PUSH2 0x20f1 203A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2031 stack[-3] = stack[-1] // @2033 stack[-1] = 0x203b // @2036 stack[0] = stack[-4] // } // Block ends with call to 0x20f1, returns to 0x203B label_203B: // Incoming return from call to 0x20F1 at 0x203A // Inputs[3] // { // @203C stack[-4] // @203C stack[-1] // @203E stack[-3] // } 203B 5B JUMPDEST 203C 92 SWAP3 203D 50 POP 203E 81 DUP2 203F 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2060 04 DIV 2061 83 DUP4 2062 11 GT 2063 82 DUP3 2064 15 ISZERO 2065 15 ISZERO 2066 16 AND 2067 15 ISZERO 2068 61 PUSH2 0x2074 206B 57 *JUMPI // Stack delta = -1 // Outputs[1] { @203C stack[-4] = stack[-1] } // Block ends with conditional jump to 0x2074, if !(!!stack[-3] & (stack[-1] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / stack[-3])) label_206C: // Incoming jump from 0x206B, if not !(!!stack[-3] & (stack[-1] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / stack[-3])) 206C 61 PUSH2 0x2073 206F 61 PUSH2 0x21b5 2072 56 *JUMP // Stack delta = +1 // Outputs[1] { @206C stack[0] = 0x2073 } // Block ends with unconditional jump to 0x21b5 2073 5B JUMPDEST label_2074: // Incoming jump from 0x206B, if !(!!stack[-3] & (stack[-1] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / stack[-3])) // Inputs[4] // { // @2075 stack[-3] // @2076 stack[-2] // @2078 stack[-1] // @207A stack[-4] // } 2074 5B JUMPDEST 2075 82 DUP3 2076 82 DUP3 2077 02 MUL 2078 90 SWAP1 2079 50 POP 207A 92 SWAP3 207B 91 SWAP2 207C 50 POP 207D 50 POP 207E 56 *JUMP // Stack delta = -3 // Outputs[1] { @207A stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_207F: // Incoming call from 0x17A4, returns to 0x17A5 // Incoming call from 0x0D9A, returns to 0x0D9B // Incoming call from 0x0AAD, returns to 0x0AAE // Inputs[1] { @2085 stack[-1] } 207F 5B JUMPDEST 2080 60 PUSH1 0x00 2082 61 PUSH2 0x208a 2085 82 DUP3 2086 61 PUSH2 0x20f1 2089 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2080 stack[0] = 0x00 // @2082 stack[1] = 0x208a // @2085 stack[2] = stack[-1] // } // Block ends with call to 0x20f1, returns to 0x208A label_208A: // Incoming return from call to 0x20F1 at 0x2089 // Inputs[3] // { // @208B stack[-3] // @208B stack[-1] // @2090 stack[-4] // } 208A 5B JUMPDEST 208B 91 SWAP2 208C 50 POP 208D 61 PUSH2 0x2095 2090 83 DUP4 2091 61 PUSH2 0x20f1 2094 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @208B stack[-3] = stack[-1] // @208D stack[-1] = 0x2095 // @2090 stack[0] = stack[-4] // } // Block ends with call to 0x20f1, returns to 0x2095 label_2095: // Incoming return from call to 0x20F1 at 0x2094 // Inputs[3] // { // @2096 stack[-1] // @2096 stack[-4] // @2099 stack[-3] // } 2095 5B JUMPDEST 2096 92 SWAP3 2097 50 POP 2098 82 DUP3 2099 82 DUP3 209A 10 LT 209B 15 ISZERO 209C 61 PUSH2 0x20a8 209F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2096 stack[-4] = stack[-1] } // Block ends with conditional jump to 0x20a8, if !(stack[-3] < stack[-1]) label_20A0: // Incoming jump from 0x209F, if not !(stack[-3] < stack[-1]) 20A0 61 PUSH2 0x20a7 20A3 61 PUSH2 0x21b5 20A6 56 *JUMP // Stack delta = +1 // Outputs[1] { @20A0 stack[0] = 0x20a7 } // Block ends with unconditional jump to 0x21b5 20A7 5B JUMPDEST label_20A8: // Incoming jump from 0x209F, if !(stack[-3] < stack[-1]) // Inputs[4] // { // @20A9 stack[-3] // @20AA stack[-2] // @20AC stack[-1] // @20AE stack[-4] // } 20A8 5B JUMPDEST 20A9 82 DUP3 20AA 82 DUP3 20AB 03 SUB 20AC 90 SWAP1 20AD 50 POP 20AE 92 SWAP3 20AF 91 SWAP2 20B0 50 POP 20B1 50 POP 20B2 56 *JUMP // Stack delta = -3 // Outputs[1] { @20AE stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_20B3: // Incoming call from 0x1A55, returns to 0x1A56 // Incoming call from 0x24E2, returns to 0x24E3 // Inputs[1] { @20B9 stack[-1] } 20B3 5B JUMPDEST 20B4 60 PUSH1 0x00 20B6 61 PUSH2 0x20be 20B9 82 DUP3 20BA 61 PUSH2 0x20d1 20BD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20B4 stack[0] = 0x00 // @20B6 stack[1] = 0x20be // @20B9 stack[2] = stack[-1] // } // Block ends with call to 0x20d1, returns to 0x20BE label_20BE: // Incoming return from call to 0x20D1 at 0x20BD // Inputs[4] // { // @20BF stack[-1] // @20BF stack[-2] // @20C1 stack[-4] // @20C2 stack[-3] // } 20BE 5B JUMPDEST 20BF 90 SWAP1 20C0 50 POP 20C1 91 SWAP2 20C2 90 SWAP1 20C3 50 POP 20C4 56 *JUMP // Stack delta = -3 // Outputs[1] { @20C1 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_20C5: // Incoming call from 0x1A64, returns to 0x1A65 // Inputs[2] // { // @20C8 stack[-1] // @20CD stack[-2] // } 20C5 5B JUMPDEST 20C6 60 PUSH1 0x00 20C8 81 DUP2 20C9 15 ISZERO 20CA 15 ISZERO 20CB 90 SWAP1 20CC 50 POP 20CD 91 SWAP2 20CE 90 SWAP1 20CF 50 POP 20D0 56 *JUMP // Stack delta = -1 // Outputs[1] { @20CD stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_20D1: // Incoming call from 0x2124, returns to 0x2125 // Incoming call from 0x20BD, returns to 0x20BE // Incoming call from 0x2148, returns to 0x2149 // Inputs[2] // { // @20E9 stack[-1] // @20ED stack[-2] // } 20D1 5B JUMPDEST 20D2 60 PUSH1 0x00 20D4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20E9 82 DUP3 20EA 16 AND 20EB 90 SWAP1 20EC 50 POP 20ED 91 SWAP2 20EE 90 SWAP1 20EF 50 POP 20F0 56 *JUMP // Stack delta = -1 // Outputs[1] { @20ED stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-2] label_20F1: // Incoming call from 0x1F11, returns to 0x1F12 // Incoming call from 0x1E68, returns to 0x1E69 // Incoming call from 0x2094, returns to 0x2095 // Incoming call from 0x24F9, returns to 0x24FA // Incoming call from 0x202F, returns to 0x2030 // Incoming call from 0x1E73, returns to 0x1E74 // Incoming call from 0x203A, returns to 0x203B // Incoming call from 0x2089, returns to 0x208A // Incoming call from 0x1C28, returns to 0x1C29 // Inputs[2] // { // @20F4 stack[-1] // @20F7 stack[-2] // } 20F1 5B JUMPDEST 20F2 60 PUSH1 0x00 20F4 81 DUP2 20F5 90 SWAP1 20F6 50 POP 20F7 91 SWAP2 20F8 90 SWAP1 20F9 50 POP 20FA 56 *JUMP // Stack delta = -1 // Outputs[1] { @20F7 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_20FB: // Incoming call from 0x1F1C, returns to 0x1F1D // Incoming call from 0x1C37, returns to 0x1C38 // Inputs[2] // { // @2100 stack[-1] // @2104 stack[-2] // } 20FB 5B JUMPDEST 20FC 60 PUSH1 0x00 20FE 60 PUSH1 0xff 2100 82 DUP3 2101 16 AND 2102 90 SWAP1 2103 50 POP 2104 91 SWAP2 2105 90 SWAP1 2106 50 POP 2107 56 *JUMP // Stack delta = -1 // Outputs[1] { @2104 stack[-2] = stack[-1] & 0xff } // Block ends with unconditional jump to stack[-2] label_2108: // Incoming call from 0x1A73, returns to 0x1A74 // Inputs[1] { @210E stack[-1] } 2108 5B JUMPDEST 2109 60 PUSH1 0x00 210B 61 PUSH2 0x2113 210E 82 DUP3 210F 61 PUSH2 0x211a 2112 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2109 stack[0] = 0x00 // @210B stack[1] = 0x2113 // @210E stack[2] = stack[-1] // } // Block ends with call to 0x211a, returns to 0x2113 label_2113: // Incoming return from call to 0x211A at 0x2112 // Inputs[4] // { // @2114 stack[-2] // @2114 stack[-1] // @2116 stack[-4] // @2117 stack[-3] // } 2113 5B JUMPDEST 2114 90 SWAP1 2115 50 POP 2116 91 SWAP2 2117 90 SWAP1 2118 50 POP 2119 56 *JUMP // Stack delta = -3 // Outputs[1] { @2116 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_211A: // Incoming call from 0x2112, returns to 0x2113 // Inputs[1] { @2120 stack[-1] } 211A 5B JUMPDEST 211B 60 PUSH1 0x00 211D 61 PUSH2 0x2125 2120 82 DUP3 2121 61 PUSH2 0x20d1 2124 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @211B stack[0] = 0x00 // @211D stack[1] = 0x2125 // @2120 stack[2] = stack[-1] // } // Block ends with call to 0x20d1, returns to 0x2125 label_2125: // Incoming return from call to 0x20D1 at 0x2124 // Inputs[4] // { // @2126 stack[-2] // @2126 stack[-1] // @2128 stack[-4] // @2129 stack[-3] // } 2125 5B JUMPDEST 2126 90 SWAP1 2127 50 POP 2128 91 SWAP2 2129 90 SWAP1 212A 50 POP 212B 56 *JUMP // Stack delta = -3 // Outputs[1] { @2128 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_212C: // Incoming call from 0x1A82, returns to 0x1A83 // Inputs[1] { @2132 stack[-1] } 212C 5B JUMPDEST 212D 60 PUSH1 0x00 212F 61 PUSH2 0x2137 2132 82 DUP3 2133 61 PUSH2 0x213e 2136 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @212D stack[0] = 0x00 // @212F stack[1] = 0x2137 // @2132 stack[2] = stack[-1] // } // Block ends with call to 0x213e, returns to 0x2137 label_2137: // Incoming return from call to 0x213E at 0x2136 // Inputs[4] // { // @2138 stack[-1] // @2138 stack[-2] // @213A stack[-4] // @213B stack[-3] // } 2137 5B JUMPDEST 2138 90 SWAP1 2139 50 POP 213A 91 SWAP2 213B 90 SWAP1 213C 50 POP 213D 56 *JUMP // Stack delta = -3 // Outputs[1] { @213A stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_213E: // Incoming call from 0x2136, returns to 0x2137 // Inputs[1] { @2144 stack[-1] } 213E 5B JUMPDEST 213F 60 PUSH1 0x00 2141 61 PUSH2 0x2149 2144 82 DUP3 2145 61 PUSH2 0x20d1 2148 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @213F stack[0] = 0x00 // @2141 stack[1] = 0x2149 // @2144 stack[2] = stack[-1] // } // Block ends with call to 0x20d1, returns to 0x2149 label_2149: // Incoming return from call to 0x20D1 at 0x2148 // Inputs[4] // { // @214A stack[-2] // @214A stack[-1] // @214C stack[-4] // @214D stack[-3] // } 2149 5B JUMPDEST 214A 90 SWAP1 214B 50 POP 214C 91 SWAP2 214D 90 SWAP1 214E 50 POP 214F 56 *JUMP // Stack delta = -3 // Outputs[1] { @214C stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2150: // Incoming call from 0x1AAD, returns to 0x1AAE // Inputs[1] { @2154 stack[-3] } 2150 5B JUMPDEST 2151 60 PUSH1 0x00 2153 5B JUMPDEST 2154 83 DUP4 2155 81 DUP2 2156 10 LT 2157 15 ISZERO 2158 61 PUSH2 0x216e 215B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2151 stack[0] = 0x00 } // Block ends with conditional jump to 0x216e, if !(0x00 < stack[-3]) label_215C: // Incoming jump from 0x215B, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x215B, if not !(0x00 < stack[-3]) // Inputs[4] // { // @215C stack[-1] // @215D stack[-2] // @215F memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2161 stack[-3] // } 215C 80 DUP1 215D 82 DUP3 215E 01 ADD 215F 51 MLOAD 2160 81 DUP2 2161 84 DUP5 2162 01 ADD 2163 52 MSTORE 2164 60 PUSH1 0x20 2166 81 DUP2 2167 01 ADD 2168 90 SWAP1 2169 50 POP 216A 61 PUSH2 0x2153 216D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2163 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2168 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2153 label_216E: // Incoming jump from 0x215B, if !(stack[-1] < stack[-4]) // Incoming jump from 0x215B, if !(0x00 < stack[-3]) // Inputs[2] // { // @216F stack[-4] // @2170 stack[-1] // } 216E 5B JUMPDEST 216F 83 DUP4 2170 81 DUP2 2171 11 GT 2172 15 ISZERO 2173 61 PUSH2 0x217d 2176 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x217d, if !(stack[-1] > stack[-4]) label_2177: // Incoming jump from 0x2176, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2179 stack[-4] // @217A stack[-3] // @2182 stack[-5] // } 2177 60 PUSH1 0x00 2179 84 DUP5 217A 84 DUP5 217B 01 ADD 217C 52 MSTORE 217D 5B JUMPDEST 217E 50 POP 217F 50 POP 2180 50 POP 2181 50 POP 2182 56 *JUMP // Stack delta = -5 // Outputs[1] { @217C memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2183: // Incoming call from 0x08FD, returns to 0x08FE // Incoming call from 0x0929, returns to 0x092A // Incoming call from 0x0C35, returns to 0x0C36 // Incoming call from 0x0C61, returns to 0x0C62 // Inputs[1] { @2188 stack[-1] } 2183 5B JUMPDEST 2184 60 PUSH1 0x00 2186 60 PUSH1 0x02 2188 82 DUP3 2189 04 DIV 218A 90 SWAP1 218B 50 POP 218C 60 PUSH1 0x01 218E 82 DUP3 218F 16 AND 2190 80 DUP1 2191 61 PUSH2 0x219b 2194 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @218A stack[0] = stack[-1] / 0x02 // @218F stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x219b, if stack[-1] & 0x01 label_2195: // Incoming jump from 0x2194, if not stack[-1] & 0x01 // Inputs[2] // { // @2197 stack[-2] // @21A0 stack[-1] // } 2195 60 PUSH1 0x7f 2197 82 DUP3 2198 16 AND 2199 91 SWAP2 219A 50 POP 219B 5B JUMPDEST 219C 60 PUSH1 0x20 219E 82 DUP3 219F 10 LT 21A0 81 DUP2 21A1 14 EQ 21A2 15 ISZERO 21A3 61 PUSH2 0x21af 21A6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2199 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x21af, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_21A7: // Incoming jump from 0x21A6, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x21A6, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) 21A7 61 PUSH2 0x21ae 21AA 61 PUSH2 0x21e4 21AD 56 *JUMP // Stack delta = +1 // Outputs[1] { @21A7 stack[0] = 0x21ae } // Block ends with unconditional jump to 0x21e4 21AE 5B JUMPDEST label_21AF: // Incoming jump from 0x21A6, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x21A6, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @21B1 stack[-2] // @21B1 stack[-4] // @21B2 stack[-3] // } 21AF 5B JUMPDEST 21B0 50 POP 21B1 91 SWAP2 21B2 90 SWAP1 21B3 50 POP 21B4 56 *JUMP // Stack delta = -3 // Outputs[1] { @21B1 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_21B5: // Incoming jump from 0x1EA7 // Incoming jump from 0x1FB7 // Incoming jump from 0x1FED // Incoming jump from 0x2072 // Incoming jump from 0x2016 // Incoming jump from 0x1FA0 // Incoming jump from 0x1ED8 // Incoming jump from 0x20A6 // Inputs[1] { @21E3 memory[0x00:0x24] } 21B5 5B JUMPDEST 21B6 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 21D7 60 PUSH1 0x00 21D9 52 MSTORE 21DA 60 PUSH1 0x11 21DC 60 PUSH1 0x04 21DE 52 MSTORE 21DF 60 PUSH1 0x24 21E1 60 PUSH1 0x00 21E3 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @21D9 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @21DE memory[0x04:0x24] = 0x11 // @21E3 revert(memory[0x00:0x24]); // } // Block terminates label_21E4: // Incoming jump from 0x21AD // Inputs[1] { @2212 memory[0x00:0x24] } 21E4 5B JUMPDEST 21E5 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 2206 60 PUSH1 0x00 2208 52 MSTORE 2209 60 PUSH1 0x22 220B 60 PUSH1 0x04 220D 52 MSTORE 220E 60 PUSH1 0x24 2210 60 PUSH1 0x00 2212 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2208 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @220D memory[0x04:0x24] = 0x22 // @2212 revert(memory[0x00:0x24]); // } // Block terminates label_2213: // Incoming jump from 0x198F // Incoming jump from 0x19D1 // Incoming jump from 0x1934 // Incoming jump from 0x1961 // Incoming jump from 0x1A22 // Inputs[1] { @2217 memory[0x00:0x00] } 2213 5B JUMPDEST 2214 60 PUSH1 0x00 2216 80 DUP1 2217 FD *REVERT // Stack delta = +0 // Outputs[1] { @2217 revert(memory[0x00:0x00]); } // Block terminates label_2218: // Incoming call from 0x1AB6, returns to 0x1AB7 // Inputs[2] // { // @2220 stack[-1] // @2225 stack[-2] // } 2218 5B JUMPDEST 2219 60 PUSH1 0x00 221B 60 PUSH1 0x1f 221D 19 NOT 221E 60 PUSH1 0x1f 2220 83 DUP4 2221 01 ADD 2222 16 AND 2223 90 SWAP1 2224 50 POP 2225 91 SWAP2 2226 90 SWAP1 2227 50 POP 2228 56 *JUMP // Stack delta = -1 // Outputs[1] { @2225 stack[-2] = stack[-1] + 0x1f & ~0x1f } // Block ends with unconditional jump to stack[-2] label_2229: // Incoming call from 0x1EF6, returns to 0x1EF7 // Incoming call from 0x1EF6, returns to 0x1EF7 // Inputs[2] // { // @222C stack[-1] // @2232 stack[-2] // } 2229 5B JUMPDEST 222A 60 PUSH1 0x00 222C 81 DUP2 222D 60 PUSH1 0x01 222F 1C SHR 2230 90 SWAP1 2231 50 POP 2232 91 SWAP2 2233 90 SWAP1 2234 50 POP 2235 56 *JUMP // Stack delta = -1 // Outputs[1] { @2232 stack[-2] = stack[-1] >> 0x01 } // Block ends with unconditional jump to stack[-2] label_2236: // Incoming call from 0x1AD9, returns to 0x1ADA // Inputs[2] // { // @225A stack[-1] // @2284 stack[-2] // } 2236 5B JUMPDEST 2237 7F PUSH32 0x4552524f523a205472616e736665722066726f6d20746865207a65726f206164 2258 60 PUSH1 0x00 225A 82 DUP3 225B 01 ADD 225C 52 MSTORE 225D 7F PUSH32 0x64726573732e0000000000000000000000000000000000000000000000000000 227E 60 PUSH1 0x20 2280 82 DUP3 2281 01 ADD 2282 52 MSTORE 2283 50 POP 2284 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @225C memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552524f523a205472616e736665722066726f6d20746865207a65726f206164 // @2282 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x64726573732e0000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_2285: // Incoming call from 0x1AFC, returns to 0x1AFD // Inputs[2] // { // @22A9 stack[-1] // @22D3 stack[-2] // } 2285 5B JUMPDEST 2286 7F PUSH32 0x4552524f523a2044656372656173656420616c6c6f77616e63652062656c6f77 22A7 60 PUSH1 0x00 22A9 82 DUP3 22AA 01 ADD 22AB 52 MSTORE 22AC 7F PUSH32 0x207a65726f2e0000000000000000000000000000000000000000000000000000 22CD 60 PUSH1 0x20 22CF 82 DUP3 22D0 01 ADD 22D1 52 MSTORE 22D2 50 POP 22D3 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @22AB memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552524f523a2044656372656173656420616c6c6f77616e63652062656c6f77 // @22D1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x207a65726f2e0000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_22D4: // Incoming call from 0x1B1F, returns to 0x1B20 // Inputs[2] // { // @22F8 stack[-1] // @2322 stack[-2] // } 22D4 5B JUMPDEST 22D5 7F PUSH32 0x4552524f523a20417070726f766520746f20746865207a65726f206164647265 22F6 60 PUSH1 0x00 22F8 82 DUP3 22F9 01 ADD 22FA 52 MSTORE 22FB 7F PUSH32 0x73732e0000000000000000000000000000000000000000000000000000000000 231C 60 PUSH1 0x20 231E 82 DUP3 231F 01 ADD 2320 52 MSTORE 2321 50 POP 2322 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @22FA memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552524f523a20417070726f766520746f20746865207a65726f206164647265 // @2320 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x73732e0000000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_2323: // Incoming call from 0x1B42, returns to 0x1B43 // Inputs[2] // { // @2347 stack[-1] // @234B stack[-2] // } 2323 5B JUMPDEST 2324 7F PUSH32 0x7065726d697373696f6e2064656e696564000000000000000000000000000000 2345 60 PUSH1 0x00 2347 82 DUP3 2348 01 ADD 2349 52 MSTORE 234A 50 POP 234B 56 *JUMP // Stack delta = -2 // Outputs[1] { @2349 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x7065726d697373696f6e2064656e696564000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_234C: // Incoming call from 0x1B65, returns to 0x1B66 // Inputs[2] // { // @2370 stack[-1] // @239A stack[-2] // } 234C 5B JUMPDEST 234D 7F PUSH32 0x4552524f523a205472616e7366657220746f20746865207a65726f2061646472 236E 60 PUSH1 0x00 2370 82 DUP3 2371 01 ADD 2372 52 MSTORE 2373 7F PUSH32 0x6573732e00000000000000000000000000000000000000000000000000000000 2394 60 PUSH1 0x20 2396 82 DUP3 2397 01 ADD 2398 52 MSTORE 2399 50 POP 239A 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2372 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552524f523a205472616e7366657220746f20746865207a65726f2061646472 // @2398 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6573732e00000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_239B: // Incoming call from 0x1B88, returns to 0x1B89 // Inputs[1] { @239D stack[-2] } 239B 5B JUMPDEST 239C 50 POP 239D 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_239E: // Incoming call from 0x1BAB, returns to 0x1BAC // Inputs[2] // { // @23C2 stack[-1] // @23EC stack[-2] // } 239E 5B JUMPDEST 239F 7F PUSH32 0x4552524f523a20417070726f76652066726f6d20746865207a65726f20616464 23C0 60 PUSH1 0x00 23C2 82 DUP3 23C3 01 ADD 23C4 52 MSTORE 23C5 7F PUSH32 0x726573732e000000000000000000000000000000000000000000000000000000 23E6 60 PUSH1 0x20 23E8 82 DUP3 23E9 01 ADD 23EA 52 MSTORE 23EB 50 POP 23EC 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @23C4 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552524f523a20417070726f76652066726f6d20746865207a65726f20616464 // @23EA memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x726573732e000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_23ED: // Incoming call from 0x1BCE, returns to 0x1BCF // Inputs[2] // { // @2411 stack[-1] // @243B stack[-2] // } 23ED 5B JUMPDEST 23EE 7F PUSH32 0x4552524f523a205472616e7366657220616d6f756e74206d7573742062652067 240F 60 PUSH1 0x00 2411 82 DUP3 2412 01 ADD 2413 52 MSTORE 2414 7F PUSH32 0x726561746572207468616e207a65726f2e000000000000000000000000000000 2435 60 PUSH1 0x20 2437 82 DUP3 2438 01 ADD 2439 52 MSTORE 243A 50 POP 243B 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2413 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552524f523a205472616e7366657220616d6f756e74206d7573742062652067 // @2439 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x726561746572207468616e207a65726f2e000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_243C: // Incoming call from 0x1BF1, returns to 0x1BF2 // Inputs[2] // { // @2460 stack[-1] // @248A stack[-2] // } 243C 5B JUMPDEST 243D 7F PUSH32 0x4552524f523a205472616e7366657220616d6f756e7420657863656564732061 245E 60 PUSH1 0x00 2460 82 DUP3 2461 01 ADD 2462 52 MSTORE 2463 7F PUSH32 0x6c6c6f77616e63652e0000000000000000000000000000000000000000000000 2484 60 PUSH1 0x20 2486 82 DUP3 2487 01 ADD 2488 52 MSTORE 2489 50 POP 248A 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2462 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552524f523a205472616e7366657220616d6f756e7420657863656564732061 // @2488 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6c6c6f77616e63652e0000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_248B: // Incoming call from 0x1C14, returns to 0x1C15 // Inputs[2] // { // @24AF stack[-1] // @24D9 stack[-2] // } 248B 5B JUMPDEST 248C 7F PUSH32 0x4552524f523a205472616e7366657220616d6f756e74206d7573742062652067 24AD 60 PUSH1 0x00 24AF 82 DUP3 24B0 01 ADD 24B1 52 MSTORE 24B2 7F PUSH32 0x726561746572207468616e20616d6f756e742e00000000000000000000000000 24D3 60 PUSH1 0x20 24D5 82 DUP3 24D6 01 ADD 24D7 52 MSTORE 24D8 50 POP 24D9 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @24B1 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552524f523a205472616e7366657220616d6f756e74206d7573742062652067 // @24D7 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x726561746572207468616e20616d6f756e742e00000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_24DA: // Incoming call from 0x1904, returns to 0x1905 // Incoming call from 0x18EF, returns to 0x18F0 // Inputs[1] { @24DE stack[-1] } 24DA 5B JUMPDEST 24DB 61 PUSH2 0x24e3 24DE 81 DUP2 24DF 61 PUSH2 0x20b3 24E2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24DB stack[0] = 0x24e3 // @24DE stack[1] = stack[-1] // } // Block ends with call to 0x20b3, returns to 0x24E3 label_24E3: // Incoming return from call to 0x20B3 at 0x24E2 // Inputs[2] // { // @24E4 stack[-2] // @24E5 stack[-1] // } 24E3 5B JUMPDEST 24E4 81 DUP2 24E5 14 EQ 24E6 61 PUSH2 0x24ee 24E9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x24ee, if stack[-2] == stack[-1] label_24EA: // Incoming jump from 0x24E9, if not stack[-2] == stack[-1] // Inputs[1] { @24ED memory[0x00:0x00] } 24EA 60 PUSH1 0x00 24EC 80 DUP1 24ED FD *REVERT // Stack delta = +0 // Outputs[1] { @24ED revert(memory[0x00:0x00]); } // Block terminates label_24EE: // Incoming jump from 0x24E9, if stack[-2] == stack[-1] // Inputs[1] { @24F0 stack[-2] } 24EE 5B JUMPDEST 24EF 50 POP 24F0 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_24F1: // Incoming call from 0x1919, returns to 0x191A // Inputs[1] { @24F5 stack[-1] } 24F1 5B JUMPDEST 24F2 61 PUSH2 0x24fa 24F5 81 DUP2 24F6 61 PUSH2 0x20f1 24F9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24F2 stack[0] = 0x24fa // @24F5 stack[1] = stack[-1] // } // Block ends with call to 0x20f1, returns to 0x24FA label_24FA: // Incoming return from call to 0x20F1 at 0x24F9 // Inputs[2] // { // @24FB stack[-2] // @24FC stack[-1] // } 24FA 5B JUMPDEST 24FB 81 DUP2 24FC 14 EQ 24FD 61 PUSH2 0x2505 2500 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2505, if stack[-2] == stack[-1] label_2501: // Incoming jump from 0x2500, if not stack[-2] == stack[-1] // Inputs[1] { @2504 memory[0x00:0x00] } 2501 60 PUSH1 0x00 2503 80 DUP1 2504 FD *REVERT // Stack delta = +0 // Outputs[1] { @2504 revert(memory[0x00:0x00]); } // Block terminates label_2505: // Incoming jump from 0x2500, if stack[-2] == stack[-1] // Inputs[1] { @2507 stack[-2] } 2505 5B JUMPDEST 2506 50 POP 2507 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 2508 FE *ASSERT 2509 A2 LOG2 250A 64 PUSH5 0x6970667358 2510 22 22 2511 12 SLT 2512 20 SHA3 2513 9A SWAP11 2514 0D 0D 2515 93 SWAP4 2516 EC EC 2517 6F PUSH16 0xca46d3b38478e278c7ecef68c4367670 2528 BC BC 2529 7D PUSH30 0xe3f444726957bb9b7f64736f6c63430008060033