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 0x01f9 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01f9, 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 0x79ba5097 0019 11 GT 001A 61 PUSH2 0x010d 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x010d, if 0x79ba5097 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x79ba5097 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa9059cbb 0024 11 GT 0025 61 PUSH2 0x00a0 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a0, if 0xa9059cbb > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa9059cbb > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xdd62ed3e 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xdd62ed3e > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xdd62ed3e > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xdd62ed3e 003A 14 EQ 003B 61 PUSH2 0x0ccf 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ccf, if 0xdd62ed3e == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xde6baccb 0045 14 EQ 0046 61 PUSH2 0x0d54 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d54, if 0xde6baccb == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xde6baccb == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe2ab691d 0050 14 EQ 0051 61 PUSH2 0x0dd1 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dd1, if 0xe2ab691d == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe2ab691d == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf26c159f 005B 14 EQ 005C 61 PUSH2 0x0e4e 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e4e, if 0xf26c159f == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf26c159f == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf2fde38b 0066 14 EQ 0067 61 PUSH2 0x0eb7 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eb7, if 0xf2fde38b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf2fde38b == stack[-1] 006B 61 PUSH2 0x01f9 006E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_006F: // Incoming jump from 0x0033, if 0xdd62ed3e > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xa9059cbb 0076 14 EQ 0077 61 PUSH2 0x0b26 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b26, if 0xa9059cbb == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xa9059cbb == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xb414d4b6 0081 14 EQ 0082 61 PUSH2 0x0b99 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b99, if 0xb414d4b6 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xb414d4b6 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xd26c4a76 008C 14 EQ 008D 61 PUSH2 0x0c02 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c02, if 0xd26c4a76 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xd26c4a76 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xd4ee1d90 0097 14 EQ 0098 61 PUSH2 0x0c78 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c78, if 0xd4ee1d90 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xd4ee1d90 == stack[-1] 009C 61 PUSH2 0x01f9 009F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_00A0: // Incoming jump from 0x0028, if 0xa9059cbb > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A0 5B JUMPDEST 00A1 80 DUP1 00A2 63 PUSH4 0x8456cb59 00A7 11 GT 00A8 61 PUSH2 0x00dc 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00dc, if 0x8456cb59 > stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x8456cb59 > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x8456cb59 00B2 14 EQ 00B3 61 PUSH2 0x09b5 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09b5, if 0x8456cb59 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x8456cb59 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x8da5cb5b 00BD 14 EQ 00BE 61 PUSH2 0x09cc 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09cc, if 0x8da5cb5b == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x95d89b41 00C8 14 EQ 00C9 61 PUSH2 0x0a23 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a23, if 0x95d89b41 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xa457c2d7 00D3 14 EQ 00D4 61 PUSH2 0x0ab3 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ab3, if 0xa457c2d7 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xa457c2d7 == stack[-1] 00D8 61 PUSH2 0x01f9 00DB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_00DC: // Incoming jump from 0x00AB, if 0x8456cb59 > stack[-1] // Inputs[1] { @00DD stack[-1] } 00DC 5B JUMPDEST 00DD 80 DUP1 00DE 63 PUSH4 0x79ba5097 00E3 14 EQ 00E4 61 PUSH2 0x084f 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x084f, if 0x79ba5097 == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x79ba5097 == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x7eee288d 00EE 14 EQ 00EF 61 PUSH2 0x087e 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x087e, if 0x7eee288d == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x7eee288d == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x82dc1ec4 00F9 14 EQ 00FA 61 PUSH2 0x08f1 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08f1, if 0x82dc1ec4 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x82dc1ec4 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x82e36586 0104 14 EQ 0105 61 PUSH2 0x0942 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0942, if 0x82e36586 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x82e36586 == stack[-1] 0109 61 PUSH2 0x01f9 010C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_010D: // Incoming jump from 0x001D, if 0x79ba5097 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @010E stack[-1] } 010D 5B JUMPDEST 010E 80 DUP1 010F 63 PUSH4 0x3f4ba83a 0114 11 GT 0115 61 PUSH2 0x0190 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0190, if 0x3f4ba83a > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x3f4ba83a > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x5c975abb 011F 11 GT 0120 61 PUSH2 0x015f 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015f, if 0x5c975abb > stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x5c975abb > stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x5c975abb 012A 14 EQ 012B 61 PUSH2 0x06ea 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ea, if 0x5c975abb == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x5c975abb == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x6b2c0f55 0135 14 EQ 0136 61 PUSH2 0x0719 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0719, if 0x6b2c0f55 == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x6b2c0f55 == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x6ef8d66d 0140 14 EQ 0141 61 PUSH2 0x076a 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x076a, if 0x6ef8d66d == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x6ef8d66d == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x70a08231 014B 14 EQ 014C 61 PUSH2 0x0781 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0781, if 0x70a08231 == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x70a08231 == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x788649ea 0156 14 EQ 0157 61 PUSH2 0x07e6 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07e6, if 0x788649ea == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x788649ea == stack[-1] 015B 61 PUSH2 0x01f9 015E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_015F: // Incoming jump from 0x0123, if 0x5c975abb > stack[-1] // Inputs[1] { @0160 stack[-1] } 015F 5B JUMPDEST 0160 80 DUP1 0161 63 PUSH4 0x3f4ba83a 0166 14 EQ 0167 61 PUSH2 0x05a0 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a0, if 0x3f4ba83a == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x3f4ba83a == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x40c10f19 0171 14 EQ 0172 61 PUSH2 0x05b7 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b7, if 0x40c10f19 == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x40c10f19 == stack[-1] // Inputs[1] { @0176 stack[-1] } 0176 80 DUP1 0177 63 PUSH4 0x46fbf68e 017C 14 EQ 017D 61 PUSH2 0x062a 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x062a, if 0x46fbf68e == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x46fbf68e == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x5c60da1b 0187 14 EQ 0188 61 PUSH2 0x0693 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0693, if 0x5c60da1b == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x5c60da1b == stack[-1] 018C 61 PUSH2 0x01f9 018F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_0190: // Incoming jump from 0x0118, if 0x3f4ba83a > stack[-1] // Inputs[1] { @0191 stack[-1] } 0190 5B JUMPDEST 0191 80 DUP1 0192 63 PUSH4 0x2f54bf6e 0197 11 GT 0198 61 PUSH2 0x01cc 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if 0x2f54bf6e > stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x2f54bf6e > stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x2f54bf6e 01A2 14 EQ 01A3 61 PUSH2 0x0442 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0442, if 0x2f54bf6e == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x2f54bf6e == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x313ce567 01AD 14 EQ 01AE 61 PUSH2 0x04ab 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ab, if 0x313ce567 == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x313ce567 == stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x3659cfe6 01B8 14 EQ 01B9 61 PUSH2 0x04dc 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04dc, if 0x3659cfe6 == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x3659cfe6 == stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x39509351 01C3 14 EQ 01C4 61 PUSH2 0x052d 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052d, if 0x39509351 == stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x39509351 == stack[-1] 01C8 61 PUSH2 0x01f9 01CB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_01CC: // Incoming jump from 0x019B, if 0x2f54bf6e > stack[-1] // Inputs[1] { @01CD stack[-1] } 01CC 5B JUMPDEST 01CD 80 DUP1 01CE 63 PUSH4 0x06fdde03 01D3 14 EQ 01D4 61 PUSH2 0x0281 01D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0281, if 0x06fdde03 == stack[-1] label_01D8: // Incoming jump from 0x01D7, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01D8 stack[-1] } 01D8 80 DUP1 01D9 63 PUSH4 0x095ea7b3 01DE 14 EQ 01DF 61 PUSH2 0x0311 01E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0311, if 0x095ea7b3 == stack[-1] label_01E3: // Incoming jump from 0x01E2, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01E3 stack[-1] } 01E3 80 DUP1 01E4 63 PUSH4 0x18160ddd 01E9 14 EQ 01EA 61 PUSH2 0x0384 01ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0384, if 0x18160ddd == stack[-1] label_01EE: // Incoming jump from 0x01ED, if not 0x18160ddd == stack[-1] // Inputs[1] { @01EE stack[-1] } 01EE 80 DUP1 01EF 63 PUSH4 0x23b872dd 01F4 14 EQ 01F5 61 PUSH2 0x03af 01F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03af, if 0x23b872dd == stack[-1] label_01F9: // Incoming jump from 0x00DB // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x010C // Incoming jump from 0x018F // Incoming jump from 0x01F8, if not 0x23b872dd == stack[-1] // Incoming jump from 0x006E // Incoming jump from 0x015E // Incoming jump from 0x01CB // Incoming jump from 0x009F // Inputs[1] { @0201 storage[0x09] } 01F9 5B JUMPDEST 01FA 60 PUSH1 0x00 01FC 60 PUSH1 0x09 01FE 60 PUSH1 0x01 0200 90 SWAP1 0201 54 SLOAD 0202 90 SWAP1 0203 61 PUSH2 0x0100 0206 0A EXP 0207 90 SWAP1 0208 04 DIV 0209 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 021E 16 AND 021F 90 SWAP1 0220 50 POP 0221 60 PUSH1 0x00 0223 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0238 16 AND 0239 81 DUP2 023A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 024F 16 AND 0250 14 EQ 0251 15 ISZERO 0252 61 PUSH2 0x025a 0255 57 *JUMPI // Stack delta = +1 // Outputs[1] { @021F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x09] / 0x0100 ** 0x01 } // Block ends with conditional jump to 0x025a, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x09] / 0x0100 ** 0x01 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0256: // Incoming jump from 0x0255, if not !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x09] / 0x0100 ** 0x01 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0259 memory[0x00:0x00] } 0256 60 PUSH1 0x00 0258 80 DUP1 0259 FD *REVERT // Stack delta = +0 // Outputs[1] { @0259 revert(memory[0x00:0x00]); } // Block terminates label_025A: // Incoming jump from 0x0255, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x09] / 0x0100 ** 0x01 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[10] // { // @025D memory[0x40:0x60] // @025E msg.data.length // @0262 msg.data[0x00:0x00 + msg.data.length] // @0266 msg.data.length // @0268 stack[-1] // @0269 msg.gas // @026A memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length] // @026A address(stack[-1]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length]) // @026B returndata.length // @0270 returndata[0x00:0x00 + returndata.length] // } 025A 5B JUMPDEST 025B 60 PUSH1 0x40 025D 51 MLOAD 025E 36 CALLDATASIZE 025F 60 PUSH1 0x00 0261 82 DUP3 0262 37 CALLDATACOPY 0263 60 PUSH1 0x00 0265 80 DUP1 0266 36 CALLDATASIZE 0267 83 DUP4 0268 85 DUP6 0269 5A GAS 026A F4 DELEGATECALL 026B 3D RETURNDATASIZE 026C 80 DUP1 026D 60 PUSH1 0x00 026F 84 DUP5 0270 3E RETURNDATACOPY 0271 81 DUP2 0272 60 PUSH1 0x00 0274 81 DUP2 0275 14 EQ 0276 61 PUSH2 0x027d 0279 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @025D stack[0] = memory[0x40:0x60] // @0262 memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @026A stack[1] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length]) // @026A memory[0x00:0x00] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length]) // @026B stack[2] = returndata.length // @0270 memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0271 stack[3] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length]) // } // Block ends with conditional jump to 0x027d, if address(stack[-1]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length]) == 0x00 label_027A: // Incoming jump from 0x0279, if not address(stack[-1]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length]) == 0x00 // Inputs[3] // { // @027A stack[-2] // @027B stack[-4] // @027C memory[stack[-4]:stack[-4] + stack[-2]] // } 027A 81 DUP2 027B 84 DUP5 027C F3 *RETURN // Stack delta = +0 // Outputs[1] { @027C return memory[stack[-4]:stack[-4] + stack[-2]]; } // Block terminates label_027D: // Incoming jump from 0x0279, if address(stack[-1]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length]) == 0x00 // Inputs[3] // { // @027E stack[-2] // @027F stack[-4] // @0280 memory[stack[-4]:stack[-4] + stack[-2]] // } 027D 5B JUMPDEST 027E 81 DUP2 027F 84 DUP5 0280 FD *REVERT // Stack delta = +0 // Outputs[1] { @0280 revert(memory[stack[-4]:stack[-4] + stack[-2]]); } // Block terminates label_0281: // Incoming jump from 0x01D7, if 0x06fdde03 == stack[-1] // Inputs[1] { @0282 msg.value } 0281 5B JUMPDEST 0282 34 CALLVALUE 0283 80 DUP1 0284 15 ISZERO 0285 61 PUSH2 0x028d 0288 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0282 stack[0] = msg.value } // Block ends with conditional jump to 0x028d, if !msg.value label_0289: // Incoming jump from 0x0288, if not !msg.value // Inputs[1] { @028C memory[0x00:0x00] } 0289 60 PUSH1 0x00 028B 80 DUP1 028C FD *REVERT // Stack delta = +0 // Outputs[1] { @028C revert(memory[0x00:0x00]); } // Block terminates label_028D: // Incoming jump from 0x0288, if !msg.value 028D 5B JUMPDEST 028E 50 POP 028F 61 PUSH2 0x0296 0292 61 PUSH2 0x0f08 0295 56 *JUMP // Stack delta = +0 // Outputs[1] { @028F stack[-1] = 0x0296 } // Block ends with call to 0x0f08, returns to 0x0296 label_0296: // Incoming return from call to 0x0F08 at 0x0295 // Inputs[4] // { // @0299 memory[0x40:0x60] // @02A4 stack[-1] // @02A7 memory[stack[-1]:stack[-1] + 0x20] // @02B0 memory[stack[-1]:stack[-1] + 0x20] // } 0296 5B JUMPDEST 0297 60 PUSH1 0x40 0299 51 MLOAD 029A 80 DUP1 029B 80 DUP1 029C 60 PUSH1 0x20 029E 01 ADD 029F 82 DUP3 02A0 81 DUP2 02A1 03 SUB 02A2 82 DUP3 02A3 52 MSTORE 02A4 83 DUP4 02A5 81 DUP2 02A6 81 DUP2 02A7 51 MLOAD 02A8 81 DUP2 02A9 52 MSTORE 02AA 60 PUSH1 0x20 02AC 01 ADD 02AD 91 SWAP2 02AE 50 POP 02AF 80 DUP1 02B0 51 MLOAD 02B1 90 SWAP1 02B2 60 PUSH1 0x20 02B4 01 ADD 02B5 90 SWAP1 02B6 80 DUP1 02B7 83 DUP4 02B8 83 DUP4 02B9 60 PUSH1 0x00 02BB 5B JUMPDEST 02BC 83 DUP4 02BD 81 DUP2 02BE 10 LT 02BF 15 ISZERO 02C0 61 PUSH2 0x02d6 02C3 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0299 stack[0] = memory[0x40:0x60] // @029A stack[1] = memory[0x40:0x60] // @02A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @02A9 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @02AD stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @02B5 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @02B5 stack[3] = 0x20 + stack[-1] // @02B6 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @02B7 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @02B8 stack[7] = 0x20 + stack[-1] // @02B9 stack[8] = 0x00 // } // Block ends with conditional jump to 0x02d6, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_02C4: // Incoming jump from 0x02C3, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x02C3, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @02C4 stack[-1] // @02C5 stack[-2] // @02C7 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @02C9 stack[-3] // } 02C4 80 DUP1 02C5 82 DUP3 02C6 01 ADD 02C7 51 MLOAD 02C8 81 DUP2 02C9 84 DUP5 02CA 01 ADD 02CB 52 MSTORE 02CC 60 PUSH1 0x20 02CE 81 DUP2 02CF 01 ADD 02D0 90 SWAP1 02D1 50 POP 02D2 61 PUSH2 0x02bb 02D5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02CB memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @02D0 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x02bb label_02D6: // Incoming jump from 0x02C3, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x02C3, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @02DB stack[-6] // @02DB stack[-5] // @02DD stack[-7] // } 02D6 5B JUMPDEST 02D7 50 POP 02D8 50 POP 02D9 50 POP 02DA 50 POP 02DB 90 SWAP1 02DC 50 POP 02DD 90 SWAP1 02DE 81 DUP2 02DF 01 ADD 02E0 90 SWAP1 02E1 60 PUSH1 0x1f 02E3 16 AND 02E4 80 DUP1 02E5 15 ISZERO 02E6 61 PUSH2 0x0303 02E9 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @02E0 stack[-7] = stack[-5] + stack[-7] // @02E3 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0303, if !(0x1f & stack[-5]) label_02EA: // Incoming jump from 0x02E9, if not !(0x1f & stack[-5]) // Inputs[6] // { // @02EA stack[-1] // @02EB stack[-2] // @02EE memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0305 stack[-5] // @030B memory[0x40:0x60] // @0310 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 02EA 80 DUP1 02EB 82 DUP3 02EC 03 SUB 02ED 80 DUP1 02EE 51 MLOAD 02EF 60 PUSH1 0x01 02F1 83 DUP4 02F2 60 PUSH1 0x20 02F4 03 SUB 02F5 61 PUSH2 0x0100 02F8 0A EXP 02F9 03 SUB 02FA 19 NOT 02FB 16 AND 02FC 81 DUP2 02FD 52 MSTORE 02FE 60 PUSH1 0x20 0300 01 ADD 0301 91 SWAP2 0302 50 POP 0303 5B JUMPDEST 0304 50 POP 0305 92 SWAP3 0306 50 POP 0307 50 POP 0308 50 POP 0309 60 PUSH1 0x40 030B 51 MLOAD 030C 80 DUP1 030D 91 SWAP2 030E 03 SUB 030F 90 SWAP1 0310 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @02FD memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0310 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0311: // Incoming jump from 0x01E2, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0312 msg.value } 0311 5B JUMPDEST 0312 34 CALLVALUE 0313 80 DUP1 0314 15 ISZERO 0315 61 PUSH2 0x031d 0318 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0312 stack[0] = msg.value } // Block ends with conditional jump to 0x031d, if !msg.value label_0319: // Incoming jump from 0x0318, if not !msg.value // Inputs[1] { @031C memory[0x00:0x00] } 0319 60 PUSH1 0x00 031B 80 DUP1 031C FD *REVERT // Stack delta = +0 // Outputs[1] { @031C revert(memory[0x00:0x00]); } // Block terminates label_031D: // Incoming jump from 0x0318, if !msg.value // Inputs[1] { @0325 msg.data.length } 031D 5B JUMPDEST 031E 50 POP 031F 61 PUSH2 0x036a 0322 60 PUSH1 0x04 0324 80 DUP1 0325 36 CALLDATASIZE 0326 03 SUB 0327 60 PUSH1 0x40 0329 81 DUP2 032A 10 LT 032B 15 ISZERO 032C 61 PUSH2 0x0334 032F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @031F stack[-1] = 0x036a // @0322 stack[0] = 0x04 // @0326 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0334, returns to 0x036A, if !(msg.data.length - 0x04 < 0x40) label_0330: // Incoming jump from 0x032F, if not !(msg.data.length - 0x04 < 0x40) // 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 call from 0x032F, returns to 0x036A, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0335 stack[-2] // @0336 stack[-1] // @033A msg.data[stack[-2]:stack[-2] + 0x20] // @035A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0334 5B JUMPDEST 0335 81 DUP2 0336 01 ADD 0337 90 SWAP1 0338 80 DUP1 0339 80 DUP1 033A 35 CALLDATALOAD 033B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0350 16 AND 0351 90 SWAP1 0352 60 PUSH1 0x20 0354 01 ADD 0355 90 SWAP1 0356 92 SWAP3 0357 91 SWAP2 0358 90 SWAP1 0359 80 DUP1 035A 35 CALLDATALOAD 035B 90 SWAP1 035C 60 PUSH1 0x20 035E 01 ADD 035F 90 SWAP1 0360 92 SWAP3 0361 91 SWAP2 0362 90 SWAP1 0363 50 POP 0364 50 POP 0365 50 POP 0366 61 PUSH2 0x0faa 0369 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0356 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0360 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0faa label_036A: // Incoming return from call to 0x0334 at 0x032F // Inputs[4] // { // @036D memory[0x40:0x60] // @036F stack[-1] // @037E memory[0x40:0x60] // @0383 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 036A 5B JUMPDEST 036B 60 PUSH1 0x40 036D 51 MLOAD 036E 80 DUP1 036F 82 DUP3 0370 15 ISZERO 0371 15 ISZERO 0372 15 ISZERO 0373 15 ISZERO 0374 81 DUP2 0375 52 MSTORE 0376 60 PUSH1 0x20 0378 01 ADD 0379 91 SWAP2 037A 50 POP 037B 50 POP 037C 60 PUSH1 0x40 037E 51 MLOAD 037F 80 DUP1 0380 91 SWAP2 0381 03 SUB 0382 90 SWAP1 0383 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0375 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0383 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0384: // Incoming jump from 0x01ED, if 0x18160ddd == stack[-1] // Inputs[1] { @0385 msg.value } 0384 5B JUMPDEST 0385 34 CALLVALUE 0386 80 DUP1 0387 15 ISZERO 0388 61 PUSH2 0x0390 038B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0385 stack[0] = msg.value } // Block ends with conditional jump to 0x0390, if !msg.value label_038C: // Incoming jump from 0x038B, if not !msg.value // Inputs[1] { @038F memory[0x00:0x00] } 038C 60 PUSH1 0x00 038E 80 DUP1 038F FD *REVERT // Stack delta = +0 // Outputs[1] { @038F revert(memory[0x00:0x00]); } // Block terminates label_0390: // Incoming jump from 0x038B, if !msg.value 0390 5B JUMPDEST 0391 50 POP 0392 61 PUSH2 0x0399 0395 61 PUSH2 0x10d5 0398 56 *JUMP // Stack delta = +0 // Outputs[1] { @0392 stack[-1] = 0x0399 } // Block ends with call to 0x10d5, returns to 0x0399 label_0399: // Incoming return from call to 0x10D5 at 0x0398 // Inputs[4] // { // @039C memory[0x40:0x60] // @039E stack[-1] // @03A9 memory[0x40:0x60] // @03AE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0399 5B JUMPDEST 039A 60 PUSH1 0x40 039C 51 MLOAD 039D 80 DUP1 039E 82 DUP3 039F 81 DUP2 03A0 52 MSTORE 03A1 60 PUSH1 0x20 03A3 01 ADD 03A4 91 SWAP2 03A5 50 POP 03A6 50 POP 03A7 60 PUSH1 0x40 03A9 51 MLOAD 03AA 80 DUP1 03AB 91 SWAP2 03AC 03 SUB 03AD 90 SWAP1 03AE F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03AE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03AF: // Incoming jump from 0x01F8, if 0x23b872dd == stack[-1] // Inputs[1] { @03B0 msg.value } 03AF 5B JUMPDEST 03B0 34 CALLVALUE 03B1 80 DUP1 03B2 15 ISZERO 03B3 61 PUSH2 0x03bb 03B6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B0 stack[0] = msg.value } // Block ends with conditional jump to 0x03bb, if !msg.value label_03B7: // Incoming jump from 0x03B6, if not !msg.value // Inputs[1] { @03BA memory[0x00:0x00] } 03B7 60 PUSH1 0x00 03B9 80 DUP1 03BA FD *REVERT // Stack delta = +0 // Outputs[1] { @03BA revert(memory[0x00:0x00]); } // Block terminates label_03BB: // Incoming jump from 0x03B6, if !msg.value // Inputs[1] { @03C3 msg.data.length } 03BB 5B JUMPDEST 03BC 50 POP 03BD 61 PUSH2 0x0428 03C0 60 PUSH1 0x04 03C2 80 DUP1 03C3 36 CALLDATASIZE 03C4 03 SUB 03C5 60 PUSH1 0x60 03C7 81 DUP2 03C8 10 LT 03C9 15 ISZERO 03CA 61 PUSH2 0x03d2 03CD 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @03BD stack[-1] = 0x0428 // @03C0 stack[0] = 0x04 // @03C4 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03d2, returns to 0x0428, if !(msg.data.length - 0x04 < 0x60) label_03CE: // Incoming jump from 0x03CD, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @03D1 memory[0x00:0x00] } 03CE 60 PUSH1 0x00 03D0 80 DUP1 03D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D1 revert(memory[0x00:0x00]); } // Block terminates label_03D2: // Incoming call from 0x03CD, returns to 0x0428, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @03D3 stack[-2] // @03D4 stack[-1] // @03D8 msg.data[stack[-2]:stack[-2] + 0x20] // @03F8 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0418 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 03D2 5B JUMPDEST 03D3 81 DUP2 03D4 01 ADD 03D5 90 SWAP1 03D6 80 DUP1 03D7 80 DUP1 03D8 35 CALLDATALOAD 03D9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03EE 16 AND 03EF 90 SWAP1 03F0 60 PUSH1 0x20 03F2 01 ADD 03F3 90 SWAP1 03F4 92 SWAP3 03F5 91 SWAP2 03F6 90 SWAP1 03F7 80 DUP1 03F8 35 CALLDATALOAD 03F9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 040E 16 AND 040F 90 SWAP1 0410 60 PUSH1 0x20 0412 01 ADD 0413 90 SWAP1 0414 92 SWAP3 0415 91 SWAP2 0416 90 SWAP1 0417 80 DUP1 0418 35 CALLDATALOAD 0419 90 SWAP1 041A 60 PUSH1 0x20 041C 01 ADD 041D 90 SWAP1 041E 92 SWAP3 041F 91 SWAP2 0420 90 SWAP1 0421 50 POP 0422 50 POP 0423 50 POP 0424 61 PUSH2 0x10df 0427 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @03F4 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0414 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @041E stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x10df label_0428: // Incoming return from call to 0x03D2 at 0x03CD // Inputs[4] // { // @042B memory[0x40:0x60] // @042D stack[-1] // @043C memory[0x40:0x60] // @0441 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0428 5B JUMPDEST 0429 60 PUSH1 0x40 042B 51 MLOAD 042C 80 DUP1 042D 82 DUP3 042E 15 ISZERO 042F 15 ISZERO 0430 15 ISZERO 0431 15 ISZERO 0432 81 DUP2 0433 52 MSTORE 0434 60 PUSH1 0x20 0436 01 ADD 0437 91 SWAP2 0438 50 POP 0439 50 POP 043A 60 PUSH1 0x40 043C 51 MLOAD 043D 80 DUP1 043E 91 SWAP2 043F 03 SUB 0440 90 SWAP1 0441 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0433 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0441 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0442: // Incoming jump from 0x01A6, if 0x2f54bf6e == stack[-1] // Inputs[1] { @0443 msg.value } 0442 5B JUMPDEST 0443 34 CALLVALUE 0444 80 DUP1 0445 15 ISZERO 0446 61 PUSH2 0x044e 0449 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0443 stack[0] = msg.value } // Block ends with conditional jump to 0x044e, if !msg.value label_044A: // Incoming jump from 0x0449, if not !msg.value // Inputs[1] { @044D memory[0x00:0x00] } 044A 60 PUSH1 0x00 044C 80 DUP1 044D FD *REVERT // Stack delta = +0 // Outputs[1] { @044D revert(memory[0x00:0x00]); } // Block terminates label_044E: // Incoming jump from 0x0449, if !msg.value // Inputs[1] { @0456 msg.data.length } 044E 5B JUMPDEST 044F 50 POP 0450 61 PUSH2 0x0491 0453 60 PUSH1 0x04 0455 80 DUP1 0456 36 CALLDATASIZE 0457 03 SUB 0458 60 PUSH1 0x20 045A 81 DUP2 045B 10 LT 045C 15 ISZERO 045D 61 PUSH2 0x0465 0460 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0450 stack[-1] = 0x0491 // @0453 stack[0] = 0x04 // @0457 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0465, returns to 0x0491, if !(msg.data.length - 0x04 < 0x20) label_0461: // Incoming jump from 0x0460, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0464 memory[0x00:0x00] } 0461 60 PUSH1 0x00 0463 80 DUP1 0464 FD *REVERT // Stack delta = +0 // Outputs[1] { @0464 revert(memory[0x00:0x00]); } // Block terminates label_0465: // Incoming call from 0x0460, returns to 0x0491, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0466 stack[-2] // @0467 stack[-1] // @046B msg.data[stack[-2]:stack[-2] + 0x20] // } 0465 5B JUMPDEST 0466 81 DUP2 0467 01 ADD 0468 90 SWAP1 0469 80 DUP1 046A 80 DUP1 046B 35 CALLDATALOAD 046C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0481 16 AND 0482 90 SWAP1 0483 60 PUSH1 0x20 0485 01 ADD 0486 90 SWAP1 0487 92 SWAP3 0488 91 SWAP2 0489 90 SWAP1 048A 50 POP 048B 50 POP 048C 50 POP 048D 61 PUSH2 0x11a4 0490 56 *JUMP // Stack delta = -1 // Outputs[1] { @0487 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x11a4 label_0491: // Incoming return from call to 0x0465 at 0x0460 // Inputs[4] // { // @0494 memory[0x40:0x60] // @0496 stack[-1] // @04A5 memory[0x40:0x60] // @04AA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0491 5B JUMPDEST 0492 60 PUSH1 0x40 0494 51 MLOAD 0495 80 DUP1 0496 82 DUP3 0497 15 ISZERO 0498 15 ISZERO 0499 15 ISZERO 049A 15 ISZERO 049B 81 DUP2 049C 52 MSTORE 049D 60 PUSH1 0x20 049F 01 ADD 04A0 91 SWAP2 04A1 50 POP 04A2 50 POP 04A3 60 PUSH1 0x40 04A5 51 MLOAD 04A6 80 DUP1 04A7 91 SWAP2 04A8 03 SUB 04A9 90 SWAP1 04AA F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @049C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @04AA return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_04AB: // Incoming jump from 0x01B1, if 0x313ce567 == stack[-1] // Inputs[1] { @04AC msg.value } 04AB 5B JUMPDEST 04AC 34 CALLVALUE 04AD 80 DUP1 04AE 15 ISZERO 04AF 61 PUSH2 0x04b7 04B2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04AC stack[0] = msg.value } // Block ends with conditional jump to 0x04b7, if !msg.value label_04B3: // Incoming jump from 0x04B2, if not !msg.value // Inputs[1] { @04B6 memory[0x00:0x00] } 04B3 60 PUSH1 0x00 04B5 80 DUP1 04B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B6 revert(memory[0x00:0x00]); } // Block terminates label_04B7: // Incoming jump from 0x04B2, if !msg.value 04B7 5B JUMPDEST 04B8 50 POP 04B9 61 PUSH2 0x04c0 04BC 61 PUSH2 0x120f 04BF 56 *JUMP // Stack delta = +0 // Outputs[1] { @04B9 stack[-1] = 0x04c0 } // Block ends with call to 0x120f, returns to 0x04C0 label_04C0: // Incoming return from call to 0x120F at 0x04BF // Inputs[4] // { // @04C3 memory[0x40:0x60] // @04C5 stack[-1] // @04D6 memory[0x40:0x60] // @04DB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 04C0 5B JUMPDEST 04C1 60 PUSH1 0x40 04C3 51 MLOAD 04C4 80 DUP1 04C5 82 DUP3 04C6 60 PUSH1 0xff 04C8 16 AND 04C9 60 PUSH1 0xff 04CB 16 AND 04CC 81 DUP2 04CD 52 MSTORE 04CE 60 PUSH1 0x20 04D0 01 ADD 04D1 91 SWAP2 04D2 50 POP 04D3 50 POP 04D4 60 PUSH1 0x40 04D6 51 MLOAD 04D7 80 DUP1 04D8 91 SWAP2 04D9 03 SUB 04DA 90 SWAP1 04DB F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @04CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1] // @04DB return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_04DC: // Incoming jump from 0x01BC, if 0x3659cfe6 == stack[-1] // Inputs[1] { @04DD msg.value } 04DC 5B JUMPDEST 04DD 34 CALLVALUE 04DE 80 DUP1 04DF 15 ISZERO 04E0 61 PUSH2 0x04e8 04E3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04DD stack[0] = msg.value } // Block ends with conditional jump to 0x04e8, if !msg.value label_04E4: // Incoming jump from 0x04E3, if not !msg.value // Inputs[1] { @04E7 memory[0x00:0x00] } 04E4 60 PUSH1 0x00 04E6 80 DUP1 04E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E7 revert(memory[0x00:0x00]); } // Block terminates label_04E8: // Incoming jump from 0x04E3, if !msg.value // Inputs[1] { @04F0 msg.data.length } 04E8 5B JUMPDEST 04E9 50 POP 04EA 61 PUSH2 0x052b 04ED 60 PUSH1 0x04 04EF 80 DUP1 04F0 36 CALLDATASIZE 04F1 03 SUB 04F2 60 PUSH1 0x20 04F4 81 DUP2 04F5 10 LT 04F6 15 ISZERO 04F7 61 PUSH2 0x04ff 04FA 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @04EA stack[-1] = 0x052b // @04ED stack[0] = 0x04 // @04F1 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04ff, returns to 0x052B, if !(msg.data.length - 0x04 < 0x20) label_04FB: // Incoming jump from 0x04FA, if not !(msg.data.length - 0x04 < 0x20) // 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 call from 0x04FA, returns to 0x052B, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0500 stack[-2] // @0501 stack[-1] // @0505 msg.data[stack[-2]:stack[-2] + 0x20] // } 04FF 5B JUMPDEST 0500 81 DUP2 0501 01 ADD 0502 90 SWAP1 0503 80 DUP1 0504 80 DUP1 0505 35 CALLDATALOAD 0506 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 051B 16 AND 051C 90 SWAP1 051D 60 PUSH1 0x20 051F 01 ADD 0520 90 SWAP1 0521 92 SWAP3 0522 91 SWAP2 0523 90 SWAP1 0524 50 POP 0525 50 POP 0526 50 POP 0527 61 PUSH2 0x1226 052A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0521 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1226 label_052B: // Incoming return from call to 0x04FF at 0x04FA 052B 5B JUMPDEST 052C 00 *STOP // Stack delta = +0 // Outputs[1] { @052C stop(); } // Block terminates label_052D: // Incoming jump from 0x01C7, if 0x39509351 == stack[-1] // Inputs[1] { @052E msg.value } 052D 5B JUMPDEST 052E 34 CALLVALUE 052F 80 DUP1 0530 15 ISZERO 0531 61 PUSH2 0x0539 0534 57 *JUMPI // Stack delta = +1 // Outputs[1] { @052E stack[0] = msg.value } // Block ends with conditional jump to 0x0539, if !msg.value label_0535: // Incoming jump from 0x0534, if not !msg.value // Inputs[1] { @0538 memory[0x00:0x00] } 0535 60 PUSH1 0x00 0537 80 DUP1 0538 FD *REVERT // Stack delta = +0 // Outputs[1] { @0538 revert(memory[0x00:0x00]); } // Block terminates label_0539: // Incoming jump from 0x0534, if !msg.value // Inputs[1] { @0541 msg.data.length } 0539 5B JUMPDEST 053A 50 POP 053B 61 PUSH2 0x0586 053E 60 PUSH1 0x04 0540 80 DUP1 0541 36 CALLDATASIZE 0542 03 SUB 0543 60 PUSH1 0x40 0545 81 DUP2 0546 10 LT 0547 15 ISZERO 0548 61 PUSH2 0x0550 054B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @053B stack[-1] = 0x0586 // @053E stack[0] = 0x04 // @0542 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0550, returns to 0x0586, if !(msg.data.length - 0x04 < 0x40) label_054C: // Incoming jump from 0x054B, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @054F memory[0x00:0x00] } 054C 60 PUSH1 0x00 054E 80 DUP1 054F FD *REVERT // Stack delta = +0 // Outputs[1] { @054F revert(memory[0x00:0x00]); } // Block terminates label_0550: // Incoming call from 0x054B, returns to 0x0586, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0551 stack[-2] // @0552 stack[-1] // @0556 msg.data[stack[-2]:stack[-2] + 0x20] // @0576 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0550 5B JUMPDEST 0551 81 DUP2 0552 01 ADD 0553 90 SWAP1 0554 80 DUP1 0555 80 DUP1 0556 35 CALLDATALOAD 0557 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 056C 16 AND 056D 90 SWAP1 056E 60 PUSH1 0x20 0570 01 ADD 0571 90 SWAP1 0572 92 SWAP3 0573 91 SWAP2 0574 90 SWAP1 0575 80 DUP1 0576 35 CALLDATALOAD 0577 90 SWAP1 0578 60 PUSH1 0x20 057A 01 ADD 057B 90 SWAP1 057C 92 SWAP3 057D 91 SWAP2 057E 90 SWAP1 057F 50 POP 0580 50 POP 0581 50 POP 0582 61 PUSH2 0x12e7 0585 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0572 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @057C stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x12e7 label_0586: // Incoming return from call to 0x0550 at 0x054B // Inputs[4] // { // @0589 memory[0x40:0x60] // @058B stack[-1] // @059A memory[0x40:0x60] // @059F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0586 5B JUMPDEST 0587 60 PUSH1 0x40 0589 51 MLOAD 058A 80 DUP1 058B 82 DUP3 058C 15 ISZERO 058D 15 ISZERO 058E 15 ISZERO 058F 15 ISZERO 0590 81 DUP2 0591 52 MSTORE 0592 60 PUSH1 0x20 0594 01 ADD 0595 91 SWAP2 0596 50 POP 0597 50 POP 0598 60 PUSH1 0x40 059A 51 MLOAD 059B 80 DUP1 059C 91 SWAP2 059D 03 SUB 059E 90 SWAP1 059F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0591 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @059F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05A0: // Incoming jump from 0x016A, if 0x3f4ba83a == stack[-1] // Inputs[1] { @05A1 msg.value } 05A0 5B JUMPDEST 05A1 34 CALLVALUE 05A2 80 DUP1 05A3 15 ISZERO 05A4 61 PUSH2 0x05ac 05A7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A1 stack[0] = msg.value } // Block ends with conditional jump to 0x05ac, if !msg.value label_05A8: // Incoming jump from 0x05A7, if not !msg.value // Inputs[1] { @05AB memory[0x00:0x00] } 05A8 60 PUSH1 0x00 05AA 80 DUP1 05AB FD *REVERT // Stack delta = +0 // Outputs[1] { @05AB revert(memory[0x00:0x00]); } // Block terminates label_05AC: // Incoming jump from 0x05A7, if !msg.value 05AC 5B JUMPDEST 05AD 50 POP 05AE 61 PUSH2 0x05b5 05B1 61 PUSH2 0x151c 05B4 56 *JUMP // Stack delta = +0 // Outputs[1] { @05AE stack[-1] = 0x05b5 } // Block ends with call to 0x151c, returns to 0x05B5 label_05B5: // Incoming return from call to 0x151C at 0x05B4 05B5 5B JUMPDEST 05B6 00 *STOP // Stack delta = +0 // Outputs[1] { @05B6 stop(); } // Block terminates label_05B7: // Incoming jump from 0x0175, if 0x40c10f19 == stack[-1] // Inputs[1] { @05B8 msg.value } 05B7 5B JUMPDEST 05B8 34 CALLVALUE 05B9 80 DUP1 05BA 15 ISZERO 05BB 61 PUSH2 0x05c3 05BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B8 stack[0] = msg.value } // Block ends with conditional jump to 0x05c3, if !msg.value label_05BF: // Incoming jump from 0x05BE, if not !msg.value // Inputs[1] { @05C2 memory[0x00:0x00] } 05BF 60 PUSH1 0x00 05C1 80 DUP1 05C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C2 revert(memory[0x00:0x00]); } // Block terminates label_05C3: // Incoming jump from 0x05BE, if !msg.value // Inputs[1] { @05CB msg.data.length } 05C3 5B JUMPDEST 05C4 50 POP 05C5 61 PUSH2 0x0610 05C8 60 PUSH1 0x04 05CA 80 DUP1 05CB 36 CALLDATASIZE 05CC 03 SUB 05CD 60 PUSH1 0x40 05CF 81 DUP2 05D0 10 LT 05D1 15 ISZERO 05D2 61 PUSH2 0x05da 05D5 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @05C5 stack[-1] = 0x0610 // @05C8 stack[0] = 0x04 // @05CC stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05da, returns to 0x0610, if !(msg.data.length - 0x04 < 0x40) label_05D6: // Incoming jump from 0x05D5, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @05D9 memory[0x00:0x00] } 05D6 60 PUSH1 0x00 05D8 80 DUP1 05D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D9 revert(memory[0x00:0x00]); } // Block terminates label_05DA: // Incoming call from 0x05D5, returns to 0x0610, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @05DB stack[-2] // @05DC stack[-1] // @05E0 msg.data[stack[-2]:stack[-2] + 0x20] // @0600 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 05DA 5B JUMPDEST 05DB 81 DUP2 05DC 01 ADD 05DD 90 SWAP1 05DE 80 DUP1 05DF 80 DUP1 05E0 35 CALLDATALOAD 05E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05F6 16 AND 05F7 90 SWAP1 05F8 60 PUSH1 0x20 05FA 01 ADD 05FB 90 SWAP1 05FC 92 SWAP3 05FD 91 SWAP2 05FE 90 SWAP1 05FF 80 DUP1 0600 35 CALLDATALOAD 0601 90 SWAP1 0602 60 PUSH1 0x20 0604 01 ADD 0605 90 SWAP1 0606 92 SWAP3 0607 91 SWAP2 0608 90 SWAP1 0609 50 POP 060A 50 POP 060B 50 POP 060C 61 PUSH2 0x15d7 060F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @05FC stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0606 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x15d7 label_0610: // Incoming return from call to 0x05DA at 0x05D5 // Inputs[4] // { // @0613 memory[0x40:0x60] // @0615 stack[-1] // @0624 memory[0x40:0x60] // @0629 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0610 5B JUMPDEST 0611 60 PUSH1 0x40 0613 51 MLOAD 0614 80 DUP1 0615 82 DUP3 0616 15 ISZERO 0617 15 ISZERO 0618 15 ISZERO 0619 15 ISZERO 061A 81 DUP2 061B 52 MSTORE 061C 60 PUSH1 0x20 061E 01 ADD 061F 91 SWAP2 0620 50 POP 0621 50 POP 0622 60 PUSH1 0x40 0624 51 MLOAD 0625 80 DUP1 0626 91 SWAP2 0627 03 SUB 0628 90 SWAP1 0629 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @061B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0629 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_062A: // Incoming jump from 0x0180, if 0x46fbf68e == stack[-1] // Inputs[1] { @062B msg.value } 062A 5B JUMPDEST 062B 34 CALLVALUE 062C 80 DUP1 062D 15 ISZERO 062E 61 PUSH2 0x0636 0631 57 *JUMPI // Stack delta = +1 // Outputs[1] { @062B stack[0] = msg.value } // Block ends with conditional jump to 0x0636, if !msg.value label_0632: // Incoming jump from 0x0631, if not !msg.value // Inputs[1] { @0635 memory[0x00:0x00] } 0632 60 PUSH1 0x00 0634 80 DUP1 0635 FD *REVERT // Stack delta = +0 // Outputs[1] { @0635 revert(memory[0x00:0x00]); } // Block terminates label_0636: // Incoming jump from 0x0631, if !msg.value // Inputs[1] { @063E msg.data.length } 0636 5B JUMPDEST 0637 50 POP 0638 61 PUSH2 0x0679 063B 60 PUSH1 0x04 063D 80 DUP1 063E 36 CALLDATASIZE 063F 03 SUB 0640 60 PUSH1 0x20 0642 81 DUP2 0643 10 LT 0644 15 ISZERO 0645 61 PUSH2 0x064d 0648 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0638 stack[-1] = 0x0679 // @063B stack[0] = 0x04 // @063F stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x064d, returns to 0x0679, if !(msg.data.length - 0x04 < 0x20) label_0649: // Incoming jump from 0x0648, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @064C memory[0x00:0x00] } 0649 60 PUSH1 0x00 064B 80 DUP1 064C FD *REVERT // Stack delta = +0 // Outputs[1] { @064C revert(memory[0x00:0x00]); } // Block terminates label_064D: // Incoming call from 0x0648, returns to 0x0679, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @064E stack[-2] // @064F stack[-1] // @0653 msg.data[stack[-2]:stack[-2] + 0x20] // } 064D 5B JUMPDEST 064E 81 DUP2 064F 01 ADD 0650 90 SWAP1 0651 80 DUP1 0652 80 DUP1 0653 35 CALLDATALOAD 0654 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0669 16 AND 066A 90 SWAP1 066B 60 PUSH1 0x20 066D 01 ADD 066E 90 SWAP1 066F 92 SWAP3 0670 91 SWAP2 0671 90 SWAP1 0672 50 POP 0673 50 POP 0674 50 POP 0675 61 PUSH2 0x1647 0678 56 *JUMP // Stack delta = -1 // Outputs[1] { @066F stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1647 label_0679: // Incoming return from call to 0x064D at 0x0648 // Inputs[4] // { // @067C memory[0x40:0x60] // @067E stack[-1] // @068D memory[0x40:0x60] // @0692 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0679 5B JUMPDEST 067A 60 PUSH1 0x40 067C 51 MLOAD 067D 80 DUP1 067E 82 DUP3 067F 15 ISZERO 0680 15 ISZERO 0681 15 ISZERO 0682 15 ISZERO 0683 81 DUP2 0684 52 MSTORE 0685 60 PUSH1 0x20 0687 01 ADD 0688 91 SWAP2 0689 50 POP 068A 50 POP 068B 60 PUSH1 0x40 068D 51 MLOAD 068E 80 DUP1 068F 91 SWAP2 0690 03 SUB 0691 90 SWAP1 0692 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0684 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0692 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0693: // Incoming jump from 0x018B, if 0x5c60da1b == stack[-1] // Inputs[1] { @0694 msg.value } 0693 5B JUMPDEST 0694 34 CALLVALUE 0695 80 DUP1 0696 15 ISZERO 0697 61 PUSH2 0x069f 069A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0694 stack[0] = msg.value } // Block ends with conditional jump to 0x069f, if !msg.value label_069B: // Incoming jump from 0x069A, if not !msg.value // Inputs[1] { @069E memory[0x00:0x00] } 069B 60 PUSH1 0x00 069D 80 DUP1 069E FD *REVERT // Stack delta = +0 // Outputs[1] { @069E revert(memory[0x00:0x00]); } // Block terminates label_069F: // Incoming jump from 0x069A, if !msg.value 069F 5B JUMPDEST 06A0 50 POP 06A1 61 PUSH2 0x06a8 06A4 61 PUSH2 0x1664 06A7 56 *JUMP // Stack delta = +0 // Outputs[1] { @06A1 stack[-1] = 0x06a8 } // Block ends with call to 0x1664, returns to 0x06A8 label_06A8: // Incoming return from call to 0x1664 at 0x06A7 // Inputs[4] // { // @06AB memory[0x40:0x60] // @06AD stack[-1] // @06E4 memory[0x40:0x60] // @06E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 06A8 5B JUMPDEST 06A9 60 PUSH1 0x40 06AB 51 MLOAD 06AC 80 DUP1 06AD 82 DUP3 06AE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06C3 16 AND 06C4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06D9 16 AND 06DA 81 DUP2 06DB 52 MSTORE 06DC 60 PUSH1 0x20 06DE 01 ADD 06DF 91 SWAP2 06E0 50 POP 06E1 50 POP 06E2 60 PUSH1 0x40 06E4 51 MLOAD 06E5 80 DUP1 06E6 91 SWAP2 06E7 03 SUB 06E8 90 SWAP1 06E9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @06DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @06E9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_06EA: // Incoming jump from 0x012E, if 0x5c975abb == stack[-1] // Inputs[1] { @06EB msg.value } 06EA 5B JUMPDEST 06EB 34 CALLVALUE 06EC 80 DUP1 06ED 15 ISZERO 06EE 61 PUSH2 0x06f6 06F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06EB stack[0] = msg.value } // Block ends with conditional jump to 0x06f6, if !msg.value label_06F2: // Incoming jump from 0x06F1, if not !msg.value // Inputs[1] { @06F5 memory[0x00:0x00] } 06F2 60 PUSH1 0x00 06F4 80 DUP1 06F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F5 revert(memory[0x00:0x00]); } // Block terminates label_06F6: // Incoming jump from 0x06F1, if !msg.value 06F6 5B JUMPDEST 06F7 50 POP 06F8 61 PUSH2 0x06ff 06FB 61 PUSH2 0x168a 06FE 56 *JUMP // Stack delta = +0 // Outputs[1] { @06F8 stack[-1] = 0x06ff } // Block ends with call to 0x168a, returns to 0x06FF label_06FF: // Incoming return from call to 0x168A at 0x06FE // Inputs[4] // { // @0702 memory[0x40:0x60] // @0704 stack[-1] // @0713 memory[0x40:0x60] // @0718 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 06FF 5B JUMPDEST 0700 60 PUSH1 0x40 0702 51 MLOAD 0703 80 DUP1 0704 82 DUP3 0705 15 ISZERO 0706 15 ISZERO 0707 15 ISZERO 0708 15 ISZERO 0709 81 DUP2 070A 52 MSTORE 070B 60 PUSH1 0x20 070D 01 ADD 070E 91 SWAP2 070F 50 POP 0710 50 POP 0711 60 PUSH1 0x40 0713 51 MLOAD 0714 80 DUP1 0715 91 SWAP2 0716 03 SUB 0717 90 SWAP1 0718 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @070A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0718 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0719: // Incoming jump from 0x0139, if 0x6b2c0f55 == stack[-1] // Inputs[1] { @071A msg.value } 0719 5B JUMPDEST 071A 34 CALLVALUE 071B 80 DUP1 071C 15 ISZERO 071D 61 PUSH2 0x0725 0720 57 *JUMPI // Stack delta = +1 // Outputs[1] { @071A stack[0] = msg.value } // Block ends with conditional jump to 0x0725, if !msg.value label_0721: // Incoming jump from 0x0720, if not !msg.value // Inputs[1] { @0724 memory[0x00:0x00] } 0721 60 PUSH1 0x00 0723 80 DUP1 0724 FD *REVERT // Stack delta = +0 // Outputs[1] { @0724 revert(memory[0x00:0x00]); } // Block terminates label_0725: // Incoming jump from 0x0720, if !msg.value // Inputs[1] { @072D msg.data.length } 0725 5B JUMPDEST 0726 50 POP 0727 61 PUSH2 0x0768 072A 60 PUSH1 0x04 072C 80 DUP1 072D 36 CALLDATASIZE 072E 03 SUB 072F 60 PUSH1 0x20 0731 81 DUP2 0732 10 LT 0733 15 ISZERO 0734 61 PUSH2 0x073c 0737 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0727 stack[-1] = 0x0768 // @072A stack[0] = 0x04 // @072E stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x073c, returns to 0x0768, if !(msg.data.length - 0x04 < 0x20) label_0738: // Incoming jump from 0x0737, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @073B memory[0x00:0x00] } 0738 60 PUSH1 0x00 073A 80 DUP1 073B FD *REVERT // Stack delta = +0 // Outputs[1] { @073B revert(memory[0x00:0x00]); } // Block terminates label_073C: // Incoming call from 0x0737, returns to 0x0768, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @073D stack[-2] // @073E stack[-1] // @0742 msg.data[stack[-2]:stack[-2] + 0x20] // } 073C 5B JUMPDEST 073D 81 DUP2 073E 01 ADD 073F 90 SWAP1 0740 80 DUP1 0741 80 DUP1 0742 35 CALLDATALOAD 0743 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0758 16 AND 0759 90 SWAP1 075A 60 PUSH1 0x20 075C 01 ADD 075D 90 SWAP1 075E 92 SWAP3 075F 91 SWAP2 0760 90 SWAP1 0761 50 POP 0762 50 POP 0763 50 POP 0764 61 PUSH2 0x16a1 0767 56 *JUMP // Stack delta = -1 // Outputs[1] { @075E stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x16a1 label_0768: // Incoming return from call to 0x073C at 0x0737 0768 5B JUMPDEST 0769 00 *STOP // Stack delta = +0 // Outputs[1] { @0769 stop(); } // Block terminates label_076A: // Incoming jump from 0x0144, if 0x6ef8d66d == stack[-1] // Inputs[1] { @076B msg.value } 076A 5B JUMPDEST 076B 34 CALLVALUE 076C 80 DUP1 076D 15 ISZERO 076E 61 PUSH2 0x0776 0771 57 *JUMPI // Stack delta = +1 // Outputs[1] { @076B stack[0] = msg.value } // Block ends with conditional jump to 0x0776, if !msg.value label_0772: // Incoming jump from 0x0771, if not !msg.value // Inputs[1] { @0775 memory[0x00:0x00] } 0772 60 PUSH1 0x00 0774 80 DUP1 0775 FD *REVERT // Stack delta = +0 // Outputs[1] { @0775 revert(memory[0x00:0x00]); } // Block terminates label_0776: // Incoming jump from 0x0771, if !msg.value 0776 5B JUMPDEST 0777 50 POP 0778 61 PUSH2 0x077f 077B 61 PUSH2 0x1707 077E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0778 stack[-1] = 0x077f } // Block ends with call to 0x1707, returns to 0x077F label_077F: // Incoming return from call to 0x1707 at 0x077E 077F 5B JUMPDEST 0780 00 *STOP // Stack delta = +0 // Outputs[1] { @0780 stop(); } // Block terminates label_0781: // Incoming jump from 0x014F, if 0x70a08231 == stack[-1] // Inputs[1] { @0782 msg.value } 0781 5B JUMPDEST 0782 34 CALLVALUE 0783 80 DUP1 0784 15 ISZERO 0785 61 PUSH2 0x078d 0788 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0782 stack[0] = msg.value } // Block ends with conditional jump to 0x078d, if !msg.value label_0789: // Incoming jump from 0x0788, if not !msg.value // Inputs[1] { @078C memory[0x00:0x00] } 0789 60 PUSH1 0x00 078B 80 DUP1 078C FD *REVERT // Stack delta = +0 // Outputs[1] { @078C revert(memory[0x00:0x00]); } // Block terminates label_078D: // Incoming jump from 0x0788, if !msg.value // Inputs[1] { @0795 msg.data.length } 078D 5B JUMPDEST 078E 50 POP 078F 61 PUSH2 0x07d0 0792 60 PUSH1 0x04 0794 80 DUP1 0795 36 CALLDATASIZE 0796 03 SUB 0797 60 PUSH1 0x20 0799 81 DUP2 079A 10 LT 079B 15 ISZERO 079C 61 PUSH2 0x07a4 079F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @078F stack[-1] = 0x07d0 // @0792 stack[0] = 0x04 // @0796 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x07a4, returns to 0x07D0, if !(msg.data.length - 0x04 < 0x20) label_07A0: // Incoming jump from 0x079F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @07A3 memory[0x00:0x00] } 07A0 60 PUSH1 0x00 07A2 80 DUP1 07A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @07A3 revert(memory[0x00:0x00]); } // Block terminates label_07A4: // Incoming call from 0x079F, returns to 0x07D0, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @07A5 stack[-2] // @07A6 stack[-1] // @07AA msg.data[stack[-2]:stack[-2] + 0x20] // } 07A4 5B JUMPDEST 07A5 81 DUP2 07A6 01 ADD 07A7 90 SWAP1 07A8 80 DUP1 07A9 80 DUP1 07AA 35 CALLDATALOAD 07AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07C0 16 AND 07C1 90 SWAP1 07C2 60 PUSH1 0x20 07C4 01 ADD 07C5 90 SWAP1 07C6 92 SWAP3 07C7 91 SWAP2 07C8 90 SWAP1 07C9 50 POP 07CA 50 POP 07CB 50 POP 07CC 61 PUSH2 0x1712 07CF 56 *JUMP // Stack delta = -1 // Outputs[1] { @07C6 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1712 label_07D0: // Incoming return from call to 0x07A4 at 0x079F // Inputs[4] // { // @07D3 memory[0x40:0x60] // @07D5 stack[-1] // @07E0 memory[0x40:0x60] // @07E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07D0 5B JUMPDEST 07D1 60 PUSH1 0x40 07D3 51 MLOAD 07D4 80 DUP1 07D5 82 DUP3 07D6 81 DUP2 07D7 52 MSTORE 07D8 60 PUSH1 0x20 07DA 01 ADD 07DB 91 SWAP2 07DC 50 POP 07DD 50 POP 07DE 60 PUSH1 0x40 07E0 51 MLOAD 07E1 80 DUP1 07E2 91 SWAP2 07E3 03 SUB 07E4 90 SWAP1 07E5 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @07D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @07E5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_07E6: // Incoming jump from 0x015A, if 0x788649ea == stack[-1] // Inputs[1] { @07E7 msg.value } 07E6 5B JUMPDEST 07E7 34 CALLVALUE 07E8 80 DUP1 07E9 15 ISZERO 07EA 61 PUSH2 0x07f2 07ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07E7 stack[0] = msg.value } // Block ends with conditional jump to 0x07f2, if !msg.value label_07EE: // Incoming jump from 0x07ED, if not !msg.value // Inputs[1] { @07F1 memory[0x00:0x00] } 07EE 60 PUSH1 0x00 07F0 80 DUP1 07F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @07F1 revert(memory[0x00:0x00]); } // Block terminates label_07F2: // Incoming jump from 0x07ED, if !msg.value // Inputs[1] { @07FA msg.data.length } 07F2 5B JUMPDEST 07F3 50 POP 07F4 61 PUSH2 0x0835 07F7 60 PUSH1 0x04 07F9 80 DUP1 07FA 36 CALLDATASIZE 07FB 03 SUB 07FC 60 PUSH1 0x20 07FE 81 DUP2 07FF 10 LT 0800 15 ISZERO 0801 61 PUSH2 0x0809 0804 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @07F4 stack[-1] = 0x0835 // @07F7 stack[0] = 0x04 // @07FB stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0809, returns to 0x0835, if !(msg.data.length - 0x04 < 0x20) label_0805: // Incoming jump from 0x0804, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0808 memory[0x00:0x00] } 0805 60 PUSH1 0x00 0807 80 DUP1 0808 FD *REVERT // Stack delta = +0 // Outputs[1] { @0808 revert(memory[0x00:0x00]); } // Block terminates label_0809: // Incoming call from 0x0804, returns to 0x0835, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @080A stack[-2] // @080B stack[-1] // @080F msg.data[stack[-2]:stack[-2] + 0x20] // } 0809 5B JUMPDEST 080A 81 DUP2 080B 01 ADD 080C 90 SWAP1 080D 80 DUP1 080E 80 DUP1 080F 35 CALLDATALOAD 0810 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0825 16 AND 0826 90 SWAP1 0827 60 PUSH1 0x20 0829 01 ADD 082A 90 SWAP1 082B 92 SWAP3 082C 91 SWAP2 082D 90 SWAP1 082E 50 POP 082F 50 POP 0830 50 POP 0831 61 PUSH2 0x1843 0834 56 *JUMP // Stack delta = -1 // Outputs[1] { @082B stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1843 label_0835: // Incoming return from call to 0x0809 at 0x0804 // Inputs[4] // { // @0838 memory[0x40:0x60] // @083A stack[-1] // @0849 memory[0x40:0x60] // @084E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0835 5B JUMPDEST 0836 60 PUSH1 0x40 0838 51 MLOAD 0839 80 DUP1 083A 82 DUP3 083B 15 ISZERO 083C 15 ISZERO 083D 15 ISZERO 083E 15 ISZERO 083F 81 DUP2 0840 52 MSTORE 0841 60 PUSH1 0x20 0843 01 ADD 0844 91 SWAP2 0845 50 POP 0846 50 POP 0847 60 PUSH1 0x40 0849 51 MLOAD 084A 80 DUP1 084B 91 SWAP2 084C 03 SUB 084D 90 SWAP1 084E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0840 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @084E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_084F: // Incoming jump from 0x00E7, if 0x79ba5097 == stack[-1] // Inputs[1] { @0850 msg.value } 084F 5B JUMPDEST 0850 34 CALLVALUE 0851 80 DUP1 0852 15 ISZERO 0853 61 PUSH2 0x085b 0856 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0850 stack[0] = msg.value } // Block ends with conditional jump to 0x085b, if !msg.value label_0857: // Incoming jump from 0x0856, if not !msg.value // Inputs[1] { @085A memory[0x00:0x00] } 0857 60 PUSH1 0x00 0859 80 DUP1 085A FD *REVERT // Stack delta = +0 // Outputs[1] { @085A revert(memory[0x00:0x00]); } // Block terminates label_085B: // Incoming jump from 0x0856, if !msg.value 085B 5B JUMPDEST 085C 50 POP 085D 61 PUSH2 0x0864 0860 61 PUSH2 0x1961 0863 56 *JUMP // Stack delta = +0 // Outputs[1] { @085D stack[-1] = 0x0864 } // Block ends with call to 0x1961, returns to 0x0864 label_0864: // Incoming return from call to 0x1961 at 0x0863 // Inputs[4] // { // @0867 memory[0x40:0x60] // @0869 stack[-1] // @0878 memory[0x40:0x60] // @087D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0864 5B JUMPDEST 0865 60 PUSH1 0x40 0867 51 MLOAD 0868 80 DUP1 0869 82 DUP3 086A 15 ISZERO 086B 15 ISZERO 086C 15 ISZERO 086D 15 ISZERO 086E 81 DUP2 086F 52 MSTORE 0870 60 PUSH1 0x20 0872 01 ADD 0873 91 SWAP2 0874 50 POP 0875 50 POP 0876 60 PUSH1 0x40 0878 51 MLOAD 0879 80 DUP1 087A 91 SWAP2 087B 03 SUB 087C 90 SWAP1 087D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @086F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @087D return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_087E: // Incoming jump from 0x00F2, if 0x7eee288d == stack[-1] // Inputs[1] { @087F msg.value } 087E 5B JUMPDEST 087F 34 CALLVALUE 0880 80 DUP1 0881 15 ISZERO 0882 61 PUSH2 0x088a 0885 57 *JUMPI // Stack delta = +1 // Outputs[1] { @087F stack[0] = msg.value } // Block ends with conditional jump to 0x088a, if !msg.value label_0886: // Incoming jump from 0x0885, if not !msg.value // Inputs[1] { @0889 memory[0x00:0x00] } 0886 60 PUSH1 0x00 0888 80 DUP1 0889 FD *REVERT // Stack delta = +0 // Outputs[1] { @0889 revert(memory[0x00:0x00]); } // Block terminates label_088A: // Incoming jump from 0x0885, if !msg.value // Inputs[1] { @0892 msg.data.length } 088A 5B JUMPDEST 088B 50 POP 088C 61 PUSH2 0x08d7 088F 60 PUSH1 0x04 0891 80 DUP1 0892 36 CALLDATASIZE 0893 03 SUB 0894 60 PUSH1 0x40 0896 81 DUP2 0897 10 LT 0898 15 ISZERO 0899 61 PUSH2 0x08a1 089C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @088C stack[-1] = 0x08d7 // @088F stack[0] = 0x04 // @0893 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x08a1, returns to 0x08D7, if !(msg.data.length - 0x04 < 0x40) label_089D: // Incoming jump from 0x089C, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @08A0 memory[0x00:0x00] } 089D 60 PUSH1 0x00 089F 80 DUP1 08A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @08A0 revert(memory[0x00:0x00]); } // Block terminates label_08A1: // Incoming call from 0x089C, returns to 0x08D7, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @08A2 stack[-2] // @08A3 stack[-1] // @08A7 msg.data[stack[-2]:stack[-2] + 0x20] // @08C7 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 08A1 5B JUMPDEST 08A2 81 DUP2 08A3 01 ADD 08A4 90 SWAP1 08A5 80 DUP1 08A6 80 DUP1 08A7 35 CALLDATALOAD 08A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08BD 16 AND 08BE 90 SWAP1 08BF 60 PUSH1 0x20 08C1 01 ADD 08C2 90 SWAP1 08C3 92 SWAP3 08C4 91 SWAP2 08C5 90 SWAP1 08C6 80 DUP1 08C7 35 CALLDATALOAD 08C8 90 SWAP1 08C9 60 PUSH1 0x20 08CB 01 ADD 08CC 90 SWAP1 08CD 92 SWAP3 08CE 91 SWAP2 08CF 90 SWAP1 08D0 50 POP 08D1 50 POP 08D2 50 POP 08D3 61 PUSH2 0x1b3c 08D6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @08C3 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @08CD stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1b3c label_08D7: // Incoming return from call to 0x08A1 at 0x089C // Inputs[4] // { // @08DA memory[0x40:0x60] // @08DC stack[-1] // @08EB memory[0x40:0x60] // @08F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08D7 5B JUMPDEST 08D8 60 PUSH1 0x40 08DA 51 MLOAD 08DB 80 DUP1 08DC 82 DUP3 08DD 15 ISZERO 08DE 15 ISZERO 08DF 15 ISZERO 08E0 15 ISZERO 08E1 81 DUP2 08E2 52 MSTORE 08E3 60 PUSH1 0x20 08E5 01 ADD 08E6 91 SWAP2 08E7 50 POP 08E8 50 POP 08E9 60 PUSH1 0x40 08EB 51 MLOAD 08EC 80 DUP1 08ED 91 SWAP2 08EE 03 SUB 08EF 90 SWAP1 08F0 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @08E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @08F0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_08F1: // Incoming jump from 0x00FD, if 0x82dc1ec4 == stack[-1] // Inputs[1] { @08F2 msg.value } 08F1 5B JUMPDEST 08F2 34 CALLVALUE 08F3 80 DUP1 08F4 15 ISZERO 08F5 61 PUSH2 0x08fd 08F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08F2 stack[0] = msg.value } // Block ends with conditional jump to 0x08fd, if !msg.value label_08F9: // Incoming jump from 0x08F8, if not !msg.value // Inputs[1] { @08FC memory[0x00:0x00] } 08F9 60 PUSH1 0x00 08FB 80 DUP1 08FC FD *REVERT // Stack delta = +0 // Outputs[1] { @08FC revert(memory[0x00:0x00]); } // Block terminates label_08FD: // Incoming jump from 0x08F8, if !msg.value // Inputs[1] { @0905 msg.data.length } 08FD 5B JUMPDEST 08FE 50 POP 08FF 61 PUSH2 0x0940 0902 60 PUSH1 0x04 0904 80 DUP1 0905 36 CALLDATASIZE 0906 03 SUB 0907 60 PUSH1 0x20 0909 81 DUP2 090A 10 LT 090B 15 ISZERO 090C 61 PUSH2 0x0914 090F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @08FF stack[-1] = 0x0940 // @0902 stack[0] = 0x04 // @0906 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0914, returns to 0x0940, if !(msg.data.length - 0x04 < 0x20) label_0910: // Incoming jump from 0x090F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0913 memory[0x00:0x00] } 0910 60 PUSH1 0x00 0912 80 DUP1 0913 FD *REVERT // Stack delta = +0 // Outputs[1] { @0913 revert(memory[0x00:0x00]); } // Block terminates label_0914: // Incoming call from 0x090F, returns to 0x0940, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0915 stack[-2] // @0916 stack[-1] // @091A msg.data[stack[-2]:stack[-2] + 0x20] // } 0914 5B JUMPDEST 0915 81 DUP2 0916 01 ADD 0917 90 SWAP1 0918 80 DUP1 0919 80 DUP1 091A 35 CALLDATALOAD 091B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0930 16 AND 0931 90 SWAP1 0932 60 PUSH1 0x20 0934 01 ADD 0935 90 SWAP1 0936 92 SWAP3 0937 91 SWAP2 0938 90 SWAP1 0939 50 POP 093A 50 POP 093B 50 POP 093C 61 PUSH2 0x1c2c 093F 56 *JUMP // Stack delta = -1 // Outputs[1] { @0936 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1c2c label_0940: // Incoming return from call to 0x0914 at 0x090F 0940 5B JUMPDEST 0941 00 *STOP // Stack delta = +0 // Outputs[1] { @0941 stop(); } // Block terminates label_0942: // Incoming jump from 0x0108, if 0x82e36586 == stack[-1] // Inputs[1] { @0943 msg.value } 0942 5B JUMPDEST 0943 34 CALLVALUE 0944 80 DUP1 0945 15 ISZERO 0946 61 PUSH2 0x094e 0949 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0943 stack[0] = msg.value } // Block ends with conditional jump to 0x094e, if !msg.value label_094A: // Incoming jump from 0x0949, if not !msg.value // Inputs[1] { @094D memory[0x00:0x00] } 094A 60 PUSH1 0x00 094C 80 DUP1 094D FD *REVERT // Stack delta = +0 // Outputs[1] { @094D revert(memory[0x00:0x00]); } // Block terminates label_094E: // Incoming jump from 0x0949, if !msg.value // Inputs[1] { @0956 msg.data.length } 094E 5B JUMPDEST 094F 50 POP 0950 61 PUSH2 0x099b 0953 60 PUSH1 0x04 0955 80 DUP1 0956 36 CALLDATASIZE 0957 03 SUB 0958 60 PUSH1 0x40 095A 81 DUP2 095B 10 LT 095C 15 ISZERO 095D 61 PUSH2 0x0965 0960 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0950 stack[-1] = 0x099b // @0953 stack[0] = 0x04 // @0957 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0965, returns to 0x099B, if !(msg.data.length - 0x04 < 0x40) label_0961: // Incoming jump from 0x0960, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0964 memory[0x00:0x00] } 0961 60 PUSH1 0x00 0963 80 DUP1 0964 FD *REVERT // Stack delta = +0 // Outputs[1] { @0964 revert(memory[0x00:0x00]); } // Block terminates label_0965: // Incoming call from 0x0960, returns to 0x099B, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0966 stack[-2] // @0967 stack[-1] // @096B msg.data[stack[-2]:stack[-2] + 0x20] // @098B msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0965 5B JUMPDEST 0966 81 DUP2 0967 01 ADD 0968 90 SWAP1 0969 80 DUP1 096A 80 DUP1 096B 35 CALLDATALOAD 096C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0981 16 AND 0982 90 SWAP1 0983 60 PUSH1 0x20 0985 01 ADD 0986 90 SWAP1 0987 92 SWAP3 0988 91 SWAP2 0989 90 SWAP1 098A 80 DUP1 098B 35 CALLDATALOAD 098C 90 SWAP1 098D 60 PUSH1 0x20 098F 01 ADD 0990 90 SWAP1 0991 92 SWAP3 0992 91 SWAP2 0993 90 SWAP1 0994 50 POP 0995 50 POP 0996 50 POP 0997 61 PUSH2 0x1c5a 099A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0987 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0991 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1c5a label_099B: // Incoming return from call to 0x0965 at 0x0960 // Inputs[4] // { // @099E memory[0x40:0x60] // @09A0 stack[-1] // @09AF memory[0x40:0x60] // @09B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 099B 5B JUMPDEST 099C 60 PUSH1 0x40 099E 51 MLOAD 099F 80 DUP1 09A0 82 DUP3 09A1 15 ISZERO 09A2 15 ISZERO 09A3 15 ISZERO 09A4 15 ISZERO 09A5 81 DUP2 09A6 52 MSTORE 09A7 60 PUSH1 0x20 09A9 01 ADD 09AA 91 SWAP2 09AB 50 POP 09AC 50 POP 09AD 60 PUSH1 0x40 09AF 51 MLOAD 09B0 80 DUP1 09B1 91 SWAP2 09B2 03 SUB 09B3 90 SWAP1 09B4 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @09A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @09B4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_09B5: // Incoming jump from 0x00B6, if 0x8456cb59 == stack[-1] // Inputs[1] { @09B6 msg.value } 09B5 5B JUMPDEST 09B6 34 CALLVALUE 09B7 80 DUP1 09B8 15 ISZERO 09B9 61 PUSH2 0x09c1 09BC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09B6 stack[0] = msg.value } // Block ends with conditional jump to 0x09c1, if !msg.value label_09BD: // Incoming jump from 0x09BC, if not !msg.value // Inputs[1] { @09C0 memory[0x00:0x00] } 09BD 60 PUSH1 0x00 09BF 80 DUP1 09C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @09C0 revert(memory[0x00:0x00]); } // Block terminates label_09C1: // Incoming jump from 0x09BC, if !msg.value 09C1 5B JUMPDEST 09C2 50 POP 09C3 61 PUSH2 0x09ca 09C6 61 PUSH2 0x1cca 09C9 56 *JUMP // Stack delta = +0 // Outputs[1] { @09C3 stack[-1] = 0x09ca } // Block ends with call to 0x1cca, returns to 0x09CA label_09CA: // Incoming return from call to 0x1CCA at 0x09C9 09CA 5B JUMPDEST 09CB 00 *STOP // Stack delta = +0 // Outputs[1] { @09CB stop(); } // Block terminates label_09CC: // Incoming jump from 0x00C1, if 0x8da5cb5b == stack[-1] // Inputs[1] { @09CD msg.value } 09CC 5B JUMPDEST 09CD 34 CALLVALUE 09CE 80 DUP1 09CF 15 ISZERO 09D0 61 PUSH2 0x09d8 09D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09CD stack[0] = msg.value } // Block ends with conditional jump to 0x09d8, if !msg.value label_09D4: // Incoming jump from 0x09D3, if not !msg.value // Inputs[1] { @09D7 memory[0x00:0x00] } 09D4 60 PUSH1 0x00 09D6 80 DUP1 09D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @09D7 revert(memory[0x00:0x00]); } // Block terminates label_09D8: // Incoming jump from 0x09D3, if !msg.value 09D8 5B JUMPDEST 09D9 50 POP 09DA 61 PUSH2 0x09e1 09DD 61 PUSH2 0x1d86 09E0 56 *JUMP // Stack delta = +0 // Outputs[1] { @09DA stack[-1] = 0x09e1 } // Block ends with call to 0x1d86, returns to 0x09E1 label_09E1: // Incoming return from call to 0x1D86 at 0x09E0 // Inputs[4] // { // @09E4 memory[0x40:0x60] // @09E6 stack[-1] // @0A1D memory[0x40:0x60] // @0A22 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09E1 5B JUMPDEST 09E2 60 PUSH1 0x40 09E4 51 MLOAD 09E5 80 DUP1 09E6 82 DUP3 09E7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09FC 16 AND 09FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A12 16 AND 0A13 81 DUP2 0A14 52 MSTORE 0A15 60 PUSH1 0x20 0A17 01 ADD 0A18 91 SWAP2 0A19 50 POP 0A1A 50 POP 0A1B 60 PUSH1 0x40 0A1D 51 MLOAD 0A1E 80 DUP1 0A1F 91 SWAP2 0A20 03 SUB 0A21 90 SWAP1 0A22 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A14 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0A22 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0A23: // Incoming jump from 0x00CC, if 0x95d89b41 == stack[-1] // Inputs[1] { @0A24 msg.value } 0A23 5B JUMPDEST 0A24 34 CALLVALUE 0A25 80 DUP1 0A26 15 ISZERO 0A27 61 PUSH2 0x0a2f 0A2A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A24 stack[0] = msg.value } // Block ends with conditional jump to 0x0a2f, if !msg.value label_0A2B: // Incoming jump from 0x0A2A, if not !msg.value // Inputs[1] { @0A2E memory[0x00:0x00] } 0A2B 60 PUSH1 0x00 0A2D 80 DUP1 0A2E FD *REVERT // Stack delta = +0 // Outputs[1] { @0A2E revert(memory[0x00:0x00]); } // Block terminates label_0A2F: // Incoming jump from 0x0A2A, if !msg.value 0A2F 5B JUMPDEST 0A30 50 POP 0A31 61 PUSH2 0x0a38 0A34 61 PUSH2 0x1dac 0A37 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A31 stack[-1] = 0x0a38 } // Block ends with call to 0x1dac, returns to 0x0A38 label_0A38: // Incoming return from call to 0x1DAC at 0x0A37 // Inputs[4] // { // @0A3B memory[0x40:0x60] // @0A46 stack[-1] // @0A49 memory[stack[-1]:stack[-1] + 0x20] // @0A52 memory[stack[-1]:stack[-1] + 0x20] // } 0A38 5B JUMPDEST 0A39 60 PUSH1 0x40 0A3B 51 MLOAD 0A3C 80 DUP1 0A3D 80 DUP1 0A3E 60 PUSH1 0x20 0A40 01 ADD 0A41 82 DUP3 0A42 81 DUP2 0A43 03 SUB 0A44 82 DUP3 0A45 52 MSTORE 0A46 83 DUP4 0A47 81 DUP2 0A48 81 DUP2 0A49 51 MLOAD 0A4A 81 DUP2 0A4B 52 MSTORE 0A4C 60 PUSH1 0x20 0A4E 01 ADD 0A4F 91 SWAP2 0A50 50 POP 0A51 80 DUP1 0A52 51 MLOAD 0A53 90 SWAP1 0A54 60 PUSH1 0x20 0A56 01 ADD 0A57 90 SWAP1 0A58 80 DUP1 0A59 83 DUP4 0A5A 83 DUP4 0A5B 60 PUSH1 0x00 0A5D 5B JUMPDEST 0A5E 83 DUP4 0A5F 81 DUP2 0A60 10 LT 0A61 15 ISZERO 0A62 61 PUSH2 0x0a78 0A65 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0A3B stack[0] = memory[0x40:0x60] // @0A3C stack[1] = memory[0x40:0x60] // @0A45 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0A4B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0A4F stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0A57 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0A57 stack[3] = 0x20 + stack[-1] // @0A58 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0A59 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0A5A stack[7] = 0x20 + stack[-1] // @0A5B stack[8] = 0x00 // } // Block ends with conditional jump to 0x0a78, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0A66: // Incoming jump from 0x0A65, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0A65, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0A66 stack[-1] // @0A67 stack[-2] // @0A69 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0A6B stack[-3] // } 0A66 80 DUP1 0A67 82 DUP3 0A68 01 ADD 0A69 51 MLOAD 0A6A 81 DUP2 0A6B 84 DUP5 0A6C 01 ADD 0A6D 52 MSTORE 0A6E 60 PUSH1 0x20 0A70 81 DUP2 0A71 01 ADD 0A72 90 SWAP1 0A73 50 POP 0A74 61 PUSH2 0x0a5d 0A77 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0A6D memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0A72 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0a5d label_0A78: // Incoming jump from 0x0A65, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0A65, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0A7D stack[-5] // @0A7D stack[-6] // @0A7F stack[-7] // } 0A78 5B JUMPDEST 0A79 50 POP 0A7A 50 POP 0A7B 50 POP 0A7C 50 POP 0A7D 90 SWAP1 0A7E 50 POP 0A7F 90 SWAP1 0A80 81 DUP2 0A81 01 ADD 0A82 90 SWAP1 0A83 60 PUSH1 0x1f 0A85 16 AND 0A86 80 DUP1 0A87 15 ISZERO 0A88 61 PUSH2 0x0aa5 0A8B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0A82 stack[-7] = stack[-5] + stack[-7] // @0A85 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0aa5, if !(0x1f & stack[-5]) label_0A8C: // Incoming jump from 0x0A8B, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0A8C stack[-1] // @0A8D stack[-2] // @0A90 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0AA7 stack[-5] // @0AAD memory[0x40:0x60] // @0AB2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0A8C 80 DUP1 0A8D 82 DUP3 0A8E 03 SUB 0A8F 80 DUP1 0A90 51 MLOAD 0A91 60 PUSH1 0x01 0A93 83 DUP4 0A94 60 PUSH1 0x20 0A96 03 SUB 0A97 61 PUSH2 0x0100 0A9A 0A EXP 0A9B 03 SUB 0A9C 19 NOT 0A9D 16 AND 0A9E 81 DUP2 0A9F 52 MSTORE 0AA0 60 PUSH1 0x20 0AA2 01 ADD 0AA3 91 SWAP2 0AA4 50 POP 0AA5 5B JUMPDEST 0AA6 50 POP 0AA7 92 SWAP3 0AA8 50 POP 0AA9 50 POP 0AAA 50 POP 0AAB 60 PUSH1 0x40 0AAD 51 MLOAD 0AAE 80 DUP1 0AAF 91 SWAP2 0AB0 03 SUB 0AB1 90 SWAP1 0AB2 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0A9F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0AB2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0AB3: // Incoming jump from 0x00D7, if 0xa457c2d7 == stack[-1] // Inputs[1] { @0AB4 msg.value } 0AB3 5B JUMPDEST 0AB4 34 CALLVALUE 0AB5 80 DUP1 0AB6 15 ISZERO 0AB7 61 PUSH2 0x0abf 0ABA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AB4 stack[0] = msg.value } // Block ends with conditional jump to 0x0abf, if !msg.value label_0ABB: // Incoming jump from 0x0ABA, if not !msg.value // Inputs[1] { @0ABE memory[0x00:0x00] } 0ABB 60 PUSH1 0x00 0ABD 80 DUP1 0ABE FD *REVERT // Stack delta = +0 // Outputs[1] { @0ABE revert(memory[0x00:0x00]); } // Block terminates label_0ABF: // Incoming jump from 0x0ABA, if !msg.value // Inputs[1] { @0AC7 msg.data.length } 0ABF 5B JUMPDEST 0AC0 50 POP 0AC1 61 PUSH2 0x0b0c 0AC4 60 PUSH1 0x04 0AC6 80 DUP1 0AC7 36 CALLDATASIZE 0AC8 03 SUB 0AC9 60 PUSH1 0x40 0ACB 81 DUP2 0ACC 10 LT 0ACD 15 ISZERO 0ACE 61 PUSH2 0x0ad6 0AD1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0AC1 stack[-1] = 0x0b0c // @0AC4 stack[0] = 0x04 // @0AC8 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0ad6, returns to 0x0B0C, if !(msg.data.length - 0x04 < 0x40) label_0AD2: // Incoming jump from 0x0AD1, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0AD5 memory[0x00:0x00] } 0AD2 60 PUSH1 0x00 0AD4 80 DUP1 0AD5 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AD5 revert(memory[0x00:0x00]); } // Block terminates label_0AD6: // Incoming call from 0x0AD1, returns to 0x0B0C, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0AD7 stack[-2] // @0AD8 stack[-1] // @0ADC msg.data[stack[-2]:stack[-2] + 0x20] // @0AFC msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0AD6 5B JUMPDEST 0AD7 81 DUP2 0AD8 01 ADD 0AD9 90 SWAP1 0ADA 80 DUP1 0ADB 80 DUP1 0ADC 35 CALLDATALOAD 0ADD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AF2 16 AND 0AF3 90 SWAP1 0AF4 60 PUSH1 0x20 0AF6 01 ADD 0AF7 90 SWAP1 0AF8 92 SWAP3 0AF9 91 SWAP2 0AFA 90 SWAP1 0AFB 80 DUP1 0AFC 35 CALLDATALOAD 0AFD 90 SWAP1 0AFE 60 PUSH1 0x20 0B00 01 ADD 0B01 90 SWAP1 0B02 92 SWAP3 0B03 91 SWAP2 0B04 90 SWAP1 0B05 50 POP 0B06 50 POP 0B07 50 POP 0B08 61 PUSH2 0x1e4e 0B0B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0AF8 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0B02 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1e4e label_0B0C: // Incoming return from call to 0x0AD6 at 0x0AD1 // Inputs[4] // { // @0B0F memory[0x40:0x60] // @0B11 stack[-1] // @0B20 memory[0x40:0x60] // @0B25 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B0C 5B JUMPDEST 0B0D 60 PUSH1 0x40 0B0F 51 MLOAD 0B10 80 DUP1 0B11 82 DUP3 0B12 15 ISZERO 0B13 15 ISZERO 0B14 15 ISZERO 0B15 15 ISZERO 0B16 81 DUP2 0B17 52 MSTORE 0B18 60 PUSH1 0x20 0B1A 01 ADD 0B1B 91 SWAP2 0B1C 50 POP 0B1D 50 POP 0B1E 60 PUSH1 0x40 0B20 51 MLOAD 0B21 80 DUP1 0B22 91 SWAP2 0B23 03 SUB 0B24 90 SWAP1 0B25 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0B17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0B25 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0B26: // Incoming jump from 0x007A, if 0xa9059cbb == stack[-1] // Inputs[1] { @0B27 msg.value } 0B26 5B JUMPDEST 0B27 34 CALLVALUE 0B28 80 DUP1 0B29 15 ISZERO 0B2A 61 PUSH2 0x0b32 0B2D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B27 stack[0] = msg.value } // Block ends with conditional jump to 0x0b32, if !msg.value label_0B2E: // Incoming jump from 0x0B2D, if not !msg.value // Inputs[1] { @0B31 memory[0x00:0x00] } 0B2E 60 PUSH1 0x00 0B30 80 DUP1 0B31 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B31 revert(memory[0x00:0x00]); } // Block terminates label_0B32: // Incoming jump from 0x0B2D, if !msg.value // Inputs[1] { @0B3A msg.data.length } 0B32 5B JUMPDEST 0B33 50 POP 0B34 61 PUSH2 0x0b7f 0B37 60 PUSH1 0x04 0B39 80 DUP1 0B3A 36 CALLDATASIZE 0B3B 03 SUB 0B3C 60 PUSH1 0x40 0B3E 81 DUP2 0B3F 10 LT 0B40 15 ISZERO 0B41 61 PUSH2 0x0b49 0B44 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0B34 stack[-1] = 0x0b7f // @0B37 stack[0] = 0x04 // @0B3B stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0b49, returns to 0x0B7F, if !(msg.data.length - 0x04 < 0x40) label_0B45: // Incoming jump from 0x0B44, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0B48 memory[0x00:0x00] } 0B45 60 PUSH1 0x00 0B47 80 DUP1 0B48 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B48 revert(memory[0x00:0x00]); } // Block terminates label_0B49: // Incoming call from 0x0B44, returns to 0x0B7F, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0B4A stack[-2] // @0B4B stack[-1] // @0B4F msg.data[stack[-2]:stack[-2] + 0x20] // @0B6F msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0B49 5B JUMPDEST 0B4A 81 DUP2 0B4B 01 ADD 0B4C 90 SWAP1 0B4D 80 DUP1 0B4E 80 DUP1 0B4F 35 CALLDATALOAD 0B50 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B65 16 AND 0B66 90 SWAP1 0B67 60 PUSH1 0x20 0B69 01 ADD 0B6A 90 SWAP1 0B6B 92 SWAP3 0B6C 91 SWAP2 0B6D 90 SWAP1 0B6E 80 DUP1 0B6F 35 CALLDATALOAD 0B70 90 SWAP1 0B71 60 PUSH1 0x20 0B73 01 ADD 0B74 90 SWAP1 0B75 92 SWAP3 0B76 91 SWAP2 0B77 90 SWAP1 0B78 50 POP 0B79 50 POP 0B7A 50 POP 0B7B 61 PUSH2 0x2083 0B7E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0B6B stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0B75 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2083 label_0B7F: // Incoming return from call to 0x0B49 at 0x0B44 // Inputs[4] // { // @0B82 memory[0x40:0x60] // @0B84 stack[-1] // @0B93 memory[0x40:0x60] // @0B98 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B7F 5B JUMPDEST 0B80 60 PUSH1 0x40 0B82 51 MLOAD 0B83 80 DUP1 0B84 82 DUP3 0B85 15 ISZERO 0B86 15 ISZERO 0B87 15 ISZERO 0B88 15 ISZERO 0B89 81 DUP2 0B8A 52 MSTORE 0B8B 60 PUSH1 0x20 0B8D 01 ADD 0B8E 91 SWAP2 0B8F 50 POP 0B90 50 POP 0B91 60 PUSH1 0x40 0B93 51 MLOAD 0B94 80 DUP1 0B95 91 SWAP2 0B96 03 SUB 0B97 90 SWAP1 0B98 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0B8A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0B98 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0B99: // Incoming jump from 0x0085, if 0xb414d4b6 == stack[-1] // Inputs[1] { @0B9A msg.value } 0B99 5B JUMPDEST 0B9A 34 CALLVALUE 0B9B 80 DUP1 0B9C 15 ISZERO 0B9D 61 PUSH2 0x0ba5 0BA0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B9A stack[0] = msg.value } // Block ends with conditional jump to 0x0ba5, if !msg.value label_0BA1: // Incoming jump from 0x0BA0, if not !msg.value // Inputs[1] { @0BA4 memory[0x00:0x00] } 0BA1 60 PUSH1 0x00 0BA3 80 DUP1 0BA4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BA4 revert(memory[0x00:0x00]); } // Block terminates label_0BA5: // Incoming jump from 0x0BA0, if !msg.value // Inputs[1] { @0BAD msg.data.length } 0BA5 5B JUMPDEST 0BA6 50 POP 0BA7 61 PUSH2 0x0be8 0BAA 60 PUSH1 0x04 0BAC 80 DUP1 0BAD 36 CALLDATASIZE 0BAE 03 SUB 0BAF 60 PUSH1 0x20 0BB1 81 DUP2 0BB2 10 LT 0BB3 15 ISZERO 0BB4 61 PUSH2 0x0bbc 0BB7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0BA7 stack[-1] = 0x0be8 // @0BAA stack[0] = 0x04 // @0BAE stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0bbc, returns to 0x0BE8, if !(msg.data.length - 0x04 < 0x20) label_0BB8: // Incoming jump from 0x0BB7, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0BBB memory[0x00:0x00] } 0BB8 60 PUSH1 0x00 0BBA 80 DUP1 0BBB FD *REVERT // Stack delta = +0 // Outputs[1] { @0BBB revert(memory[0x00:0x00]); } // Block terminates label_0BBC: // Incoming call from 0x0BB7, returns to 0x0BE8, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0BBD stack[-2] // @0BBE stack[-1] // @0BC2 msg.data[stack[-2]:stack[-2] + 0x20] // } 0BBC 5B JUMPDEST 0BBD 81 DUP2 0BBE 01 ADD 0BBF 90 SWAP1 0BC0 80 DUP1 0BC1 80 DUP1 0BC2 35 CALLDATALOAD 0BC3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BD8 16 AND 0BD9 90 SWAP1 0BDA 60 PUSH1 0x20 0BDC 01 ADD 0BDD 90 SWAP1 0BDE 92 SWAP3 0BDF 91 SWAP2 0BE0 90 SWAP1 0BE1 50 POP 0BE2 50 POP 0BE3 50 POP 0BE4 61 PUSH2 0x2146 0BE7 56 *JUMP // Stack delta = -1 // Outputs[1] { @0BDE stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2146 label_0BE8: // Incoming return from call to 0x0BBC at 0x0BB7 // Inputs[4] // { // @0BEB memory[0x40:0x60] // @0BED stack[-1] // @0BFC memory[0x40:0x60] // @0C01 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BE8 5B JUMPDEST 0BE9 60 PUSH1 0x40 0BEB 51 MLOAD 0BEC 80 DUP1 0BED 82 DUP3 0BEE 15 ISZERO 0BEF 15 ISZERO 0BF0 15 ISZERO 0BF1 15 ISZERO 0BF2 81 DUP2 0BF3 52 MSTORE 0BF4 60 PUSH1 0x20 0BF6 01 ADD 0BF7 91 SWAP2 0BF8 50 POP 0BF9 50 POP 0BFA 60 PUSH1 0x40 0BFC 51 MLOAD 0BFD 80 DUP1 0BFE 91 SWAP2 0BFF 03 SUB 0C00 90 SWAP1 0C01 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0BF3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0C01 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0C02: // Incoming jump from 0x0090, if 0xd26c4a76 == stack[-1] // Inputs[1] { @0C03 msg.value } 0C02 5B JUMPDEST 0C03 34 CALLVALUE 0C04 80 DUP1 0C05 15 ISZERO 0C06 61 PUSH2 0x0c0e 0C09 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C03 stack[0] = msg.value } // Block ends with conditional jump to 0x0c0e, if !msg.value label_0C0A: // Incoming jump from 0x0C09, if not !msg.value // Inputs[1] { @0C0D memory[0x00:0x00] } 0C0A 60 PUSH1 0x00 0C0C 80 DUP1 0C0D FD *REVERT // Stack delta = +0 // Outputs[1] { @0C0D revert(memory[0x00:0x00]); } // Block terminates label_0C0E: // Incoming jump from 0x0C09, if !msg.value // Inputs[1] { @0C16 msg.data.length } 0C0E 5B JUMPDEST 0C0F 50 POP 0C10 61 PUSH2 0x0c5b 0C13 60 PUSH1 0x04 0C15 80 DUP1 0C16 36 CALLDATASIZE 0C17 03 SUB 0C18 60 PUSH1 0x40 0C1A 81 DUP2 0C1B 10 LT 0C1C 15 ISZERO 0C1D 61 PUSH2 0x0c25 0C20 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0C10 stack[-1] = 0x0c5b // @0C13 stack[0] = 0x04 // @0C17 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0c25, returns to 0x0C5B, if !(msg.data.length - 0x04 < 0x40) label_0C21: // Incoming jump from 0x0C20, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0C24 memory[0x00:0x00] } 0C21 60 PUSH1 0x00 0C23 80 DUP1 0C24 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C24 revert(memory[0x00:0x00]); } // Block terminates label_0C25: // Incoming call from 0x0C20, returns to 0x0C5B, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0C26 stack[-2] // @0C27 stack[-1] // @0C2B msg.data[stack[-2]:stack[-2] + 0x20] // @0C4B msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0C25 5B JUMPDEST 0C26 81 DUP2 0C27 01 ADD 0C28 90 SWAP1 0C29 80 DUP1 0C2A 80 DUP1 0C2B 35 CALLDATALOAD 0C2C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C41 16 AND 0C42 90 SWAP1 0C43 60 PUSH1 0x20 0C45 01 ADD 0C46 90 SWAP1 0C47 92 SWAP3 0C48 91 SWAP2 0C49 90 SWAP1 0C4A 80 DUP1 0C4B 35 CALLDATALOAD 0C4C 90 SWAP1 0C4D 60 PUSH1 0x20 0C4F 01 ADD 0C50 90 SWAP1 0C51 92 SWAP3 0C52 91 SWAP2 0C53 90 SWAP1 0C54 50 POP 0C55 50 POP 0C56 50 POP 0C57 61 PUSH2 0x2166 0C5A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0C47 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0C51 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2166 label_0C5B: // Incoming return from call to 0x0C25 at 0x0C20 // Inputs[5] // { // @0C5E memory[0x40:0x60] // @0C60 stack[-2] // @0C66 stack[-1] // @0C72 memory[0x40:0x60] // @0C77 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C5B 5B JUMPDEST 0C5C 60 PUSH1 0x40 0C5E 51 MLOAD 0C5F 80 DUP1 0C60 83 DUP4 0C61 81 DUP2 0C62 52 MSTORE 0C63 60 PUSH1 0x20 0C65 01 ADD 0C66 82 DUP3 0C67 81 DUP2 0C68 52 MSTORE 0C69 60 PUSH1 0x20 0C6B 01 ADD 0C6C 92 SWAP3 0C6D 50 POP 0C6E 50 POP 0C6F 50 POP 0C70 60 PUSH1 0x40 0C72 51 MLOAD 0C73 80 DUP1 0C74 91 SWAP2 0C75 03 SUB 0C76 90 SWAP1 0C77 F3 *RETURN // Stack delta = -2 // Outputs[3] // { // @0C62 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0C68 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-1] // @0C77 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0C78: // Incoming jump from 0x009B, if 0xd4ee1d90 == stack[-1] // Inputs[1] { @0C79 msg.value } 0C78 5B JUMPDEST 0C79 34 CALLVALUE 0C7A 80 DUP1 0C7B 15 ISZERO 0C7C 61 PUSH2 0x0c84 0C7F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C79 stack[0] = msg.value } // Block ends with conditional jump to 0x0c84, if !msg.value label_0C80: // Incoming jump from 0x0C7F, if not !msg.value // Inputs[1] { @0C83 memory[0x00:0x00] } 0C80 60 PUSH1 0x00 0C82 80 DUP1 0C83 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C83 revert(memory[0x00:0x00]); } // Block terminates label_0C84: // Incoming jump from 0x0C7F, if !msg.value 0C84 5B JUMPDEST 0C85 50 POP 0C86 61 PUSH2 0x0c8d 0C89 61 PUSH2 0x21a4 0C8C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0C86 stack[-1] = 0x0c8d } // Block ends with call to 0x21a4, returns to 0x0C8D label_0C8D: // Incoming return from call to 0x21A4 at 0x0C8C // Inputs[4] // { // @0C90 memory[0x40:0x60] // @0C92 stack[-1] // @0CC9 memory[0x40:0x60] // @0CCE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C8D 5B JUMPDEST 0C8E 60 PUSH1 0x40 0C90 51 MLOAD 0C91 80 DUP1 0C92 82 DUP3 0C93 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CA8 16 AND 0CA9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CBE 16 AND 0CBF 81 DUP2 0CC0 52 MSTORE 0CC1 60 PUSH1 0x20 0CC3 01 ADD 0CC4 91 SWAP2 0CC5 50 POP 0CC6 50 POP 0CC7 60 PUSH1 0x40 0CC9 51 MLOAD 0CCA 80 DUP1 0CCB 91 SWAP2 0CCC 03 SUB 0CCD 90 SWAP1 0CCE F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0CC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0CCE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0CCF: // Incoming jump from 0x003E, if 0xdd62ed3e == stack[-1] // Inputs[1] { @0CD0 msg.value } 0CCF 5B JUMPDEST 0CD0 34 CALLVALUE 0CD1 80 DUP1 0CD2 15 ISZERO 0CD3 61 PUSH2 0x0cdb 0CD6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0CD0 stack[0] = msg.value } // Block ends with conditional jump to 0x0cdb, if !msg.value label_0CD7: // Incoming jump from 0x0CD6, if not !msg.value // Inputs[1] { @0CDA memory[0x00:0x00] } 0CD7 60 PUSH1 0x00 0CD9 80 DUP1 0CDA FD *REVERT // Stack delta = +0 // Outputs[1] { @0CDA revert(memory[0x00:0x00]); } // Block terminates label_0CDB: // Incoming jump from 0x0CD6, if !msg.value // Inputs[1] { @0CE3 msg.data.length } 0CDB 5B JUMPDEST 0CDC 50 POP 0CDD 61 PUSH2 0x0d3e 0CE0 60 PUSH1 0x04 0CE2 80 DUP1 0CE3 36 CALLDATASIZE 0CE4 03 SUB 0CE5 60 PUSH1 0x40 0CE7 81 DUP2 0CE8 10 LT 0CE9 15 ISZERO 0CEA 61 PUSH2 0x0cf2 0CED 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0CDD stack[-1] = 0x0d3e // @0CE0 stack[0] = 0x04 // @0CE4 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0cf2, returns to 0x0D3E, if !(msg.data.length - 0x04 < 0x40) label_0CEE: // Incoming jump from 0x0CED, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0CF1 memory[0x00:0x00] } 0CEE 60 PUSH1 0x00 0CF0 80 DUP1 0CF1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CF1 revert(memory[0x00:0x00]); } // Block terminates label_0CF2: // Incoming call from 0x0CED, returns to 0x0D3E, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0CF3 stack[-2] // @0CF4 stack[-1] // @0CF8 msg.data[stack[-2]:stack[-2] + 0x20] // @0D18 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0CF2 5B JUMPDEST 0CF3 81 DUP2 0CF4 01 ADD 0CF5 90 SWAP1 0CF6 80 DUP1 0CF7 80 DUP1 0CF8 35 CALLDATALOAD 0CF9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D0E 16 AND 0D0F 90 SWAP1 0D10 60 PUSH1 0x20 0D12 01 ADD 0D13 90 SWAP1 0D14 92 SWAP3 0D15 91 SWAP2 0D16 90 SWAP1 0D17 80 DUP1 0D18 35 CALLDATALOAD 0D19 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D2E 16 AND 0D2F 90 SWAP1 0D30 60 PUSH1 0x20 0D32 01 ADD 0D33 90 SWAP1 0D34 92 SWAP3 0D35 91 SWAP2 0D36 90 SWAP1 0D37 50 POP 0D38 50 POP 0D39 50 POP 0D3A 61 PUSH2 0x21ca 0D3D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0D14 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0D34 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x21ca label_0D3E: // Incoming return from call to 0x0CF2 at 0x0CED // Inputs[4] // { // @0D41 memory[0x40:0x60] // @0D43 stack[-1] // @0D4E memory[0x40:0x60] // @0D53 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D3E 5B JUMPDEST 0D3F 60 PUSH1 0x40 0D41 51 MLOAD 0D42 80 DUP1 0D43 82 DUP3 0D44 81 DUP2 0D45 52 MSTORE 0D46 60 PUSH1 0x20 0D48 01 ADD 0D49 91 SWAP2 0D4A 50 POP 0D4B 50 POP 0D4C 60 PUSH1 0x40 0D4E 51 MLOAD 0D4F 80 DUP1 0D50 91 SWAP2 0D51 03 SUB 0D52 90 SWAP1 0D53 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0D45 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0D53 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0D54: // Incoming jump from 0x0049, if 0xde6baccb == stack[-1] // Inputs[1] { @0D55 msg.value } 0D54 5B JUMPDEST 0D55 34 CALLVALUE 0D56 80 DUP1 0D57 15 ISZERO 0D58 61 PUSH2 0x0d60 0D5B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D55 stack[0] = msg.value } // Block ends with conditional jump to 0x0d60, if !msg.value label_0D5C: // Incoming jump from 0x0D5B, if not !msg.value // Inputs[1] { @0D5F memory[0x00:0x00] } 0D5C 60 PUSH1 0x00 0D5E 80 DUP1 0D5F FD *REVERT // Stack delta = +0 // Outputs[1] { @0D5F revert(memory[0x00:0x00]); } // Block terminates label_0D60: // Incoming jump from 0x0D5B, if !msg.value // Inputs[1] { @0D68 msg.data.length } 0D60 5B JUMPDEST 0D61 50 POP 0D62 61 PUSH2 0x0db7 0D65 60 PUSH1 0x04 0D67 80 DUP1 0D68 36 CALLDATASIZE 0D69 03 SUB 0D6A 60 PUSH1 0x60 0D6C 81 DUP2 0D6D 10 LT 0D6E 15 ISZERO 0D6F 61 PUSH2 0x0d77 0D72 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0D62 stack[-1] = 0x0db7 // @0D65 stack[0] = 0x04 // @0D69 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0d77, returns to 0x0DB7, if !(msg.data.length - 0x04 < 0x60) label_0D73: // Incoming jump from 0x0D72, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0D76 memory[0x00:0x00] } 0D73 60 PUSH1 0x00 0D75 80 DUP1 0D76 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D76 revert(memory[0x00:0x00]); } // Block terminates label_0D77: // Incoming call from 0x0D72, returns to 0x0DB7, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0D78 stack[-2] // @0D79 stack[-1] // @0D7D msg.data[stack[-2]:stack[-2] + 0x20] // @0D9D msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0DA7 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0D77 5B JUMPDEST 0D78 81 DUP2 0D79 01 ADD 0D7A 90 SWAP1 0D7B 80 DUP1 0D7C 80 DUP1 0D7D 35 CALLDATALOAD 0D7E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D93 16 AND 0D94 90 SWAP1 0D95 60 PUSH1 0x20 0D97 01 ADD 0D98 90 SWAP1 0D99 92 SWAP3 0D9A 91 SWAP2 0D9B 90 SWAP1 0D9C 80 DUP1 0D9D 35 CALLDATALOAD 0D9E 90 SWAP1 0D9F 60 PUSH1 0x20 0DA1 01 ADD 0DA2 90 SWAP1 0DA3 92 SWAP3 0DA4 91 SWAP2 0DA5 90 SWAP1 0DA6 80 DUP1 0DA7 35 CALLDATALOAD 0DA8 90 SWAP1 0DA9 60 PUSH1 0x20 0DAB 01 ADD 0DAC 90 SWAP1 0DAD 92 SWAP3 0DAE 91 SWAP2 0DAF 90 SWAP1 0DB0 50 POP 0DB1 50 POP 0DB2 50 POP 0DB3 61 PUSH2 0x2251 0DB6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0D99 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0DA3 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0DAD stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2251 label_0DB7: // Incoming return from call to 0x0D77 at 0x0D72 // Inputs[4] // { // @0DBA memory[0x40:0x60] // @0DBC stack[-1] // @0DCB memory[0x40:0x60] // @0DD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DB7 5B JUMPDEST 0DB8 60 PUSH1 0x40 0DBA 51 MLOAD 0DBB 80 DUP1 0DBC 82 DUP3 0DBD 15 ISZERO 0DBE 15 ISZERO 0DBF 15 ISZERO 0DC0 15 ISZERO 0DC1 81 DUP2 0DC2 52 MSTORE 0DC3 60 PUSH1 0x20 0DC5 01 ADD 0DC6 91 SWAP2 0DC7 50 POP 0DC8 50 POP 0DC9 60 PUSH1 0x40 0DCB 51 MLOAD 0DCC 80 DUP1 0DCD 91 SWAP2 0DCE 03 SUB 0DCF 90 SWAP1 0DD0 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0DC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0DD0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0DD1: // Incoming jump from 0x0054, if 0xe2ab691d == stack[-1] // Inputs[1] { @0DD2 msg.value } 0DD1 5B JUMPDEST 0DD2 34 CALLVALUE 0DD3 80 DUP1 0DD4 15 ISZERO 0DD5 61 PUSH2 0x0ddd 0DD8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DD2 stack[0] = msg.value } // Block ends with conditional jump to 0x0ddd, if !msg.value label_0DD9: // Incoming jump from 0x0DD8, if not !msg.value // Inputs[1] { @0DDC memory[0x00:0x00] } 0DD9 60 PUSH1 0x00 0DDB 80 DUP1 0DDC FD *REVERT // Stack delta = +0 // Outputs[1] { @0DDC revert(memory[0x00:0x00]); } // Block terminates label_0DDD: // Incoming jump from 0x0DD8, if !msg.value // Inputs[1] { @0DE5 msg.data.length } 0DDD 5B JUMPDEST 0DDE 50 POP 0DDF 61 PUSH2 0x0e34 0DE2 60 PUSH1 0x04 0DE4 80 DUP1 0DE5 36 CALLDATASIZE 0DE6 03 SUB 0DE7 60 PUSH1 0x60 0DE9 81 DUP2 0DEA 10 LT 0DEB 15 ISZERO 0DEC 61 PUSH2 0x0df4 0DEF 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0DDF stack[-1] = 0x0e34 // @0DE2 stack[0] = 0x04 // @0DE6 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0df4, returns to 0x0E34, if !(msg.data.length - 0x04 < 0x60) label_0DF0: // Incoming jump from 0x0DEF, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0DF3 memory[0x00:0x00] } 0DF0 60 PUSH1 0x00 0DF2 80 DUP1 0DF3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DF3 revert(memory[0x00:0x00]); } // Block terminates label_0DF4: // Incoming call from 0x0DEF, returns to 0x0E34, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0DF5 stack[-2] // @0DF6 stack[-1] // @0DFA msg.data[stack[-2]:stack[-2] + 0x20] // @0E1A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0E24 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0DF4 5B JUMPDEST 0DF5 81 DUP2 0DF6 01 ADD 0DF7 90 SWAP1 0DF8 80 DUP1 0DF9 80 DUP1 0DFA 35 CALLDATALOAD 0DFB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E10 16 AND 0E11 90 SWAP1 0E12 60 PUSH1 0x20 0E14 01 ADD 0E15 90 SWAP1 0E16 92 SWAP3 0E17 91 SWAP2 0E18 90 SWAP1 0E19 80 DUP1 0E1A 35 CALLDATALOAD 0E1B 90 SWAP1 0E1C 60 PUSH1 0x20 0E1E 01 ADD 0E1F 90 SWAP1 0E20 92 SWAP3 0E21 91 SWAP2 0E22 90 SWAP1 0E23 80 DUP1 0E24 35 CALLDATALOAD 0E25 90 SWAP1 0E26 60 PUSH1 0x20 0E28 01 ADD 0E29 90 SWAP1 0E2A 92 SWAP3 0E2B 91 SWAP2 0E2C 90 SWAP1 0E2D 50 POP 0E2E 50 POP 0E2F 50 POP 0E30 61 PUSH2 0x2297 0E33 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0E16 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0E20 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0E2A stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2297 label_0E34: // Incoming return from call to 0x0DF4 at 0x0DEF // Inputs[4] // { // @0E37 memory[0x40:0x60] // @0E39 stack[-1] // @0E48 memory[0x40:0x60] // @0E4D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E34 5B JUMPDEST 0E35 60 PUSH1 0x40 0E37 51 MLOAD 0E38 80 DUP1 0E39 82 DUP3 0E3A 15 ISZERO 0E3B 15 ISZERO 0E3C 15 ISZERO 0E3D 15 ISZERO 0E3E 81 DUP2 0E3F 52 MSTORE 0E40 60 PUSH1 0x20 0E42 01 ADD 0E43 91 SWAP2 0E44 50 POP 0E45 50 POP 0E46 60 PUSH1 0x40 0E48 51 MLOAD 0E49 80 DUP1 0E4A 91 SWAP2 0E4B 03 SUB 0E4C 90 SWAP1 0E4D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0E3F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0E4D return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0E4E: // Incoming jump from 0x005F, if 0xf26c159f == stack[-1] // Inputs[1] { @0E4F msg.value } 0E4E 5B JUMPDEST 0E4F 34 CALLVALUE 0E50 80 DUP1 0E51 15 ISZERO 0E52 61 PUSH2 0x0e5a 0E55 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E4F stack[0] = msg.value } // Block ends with conditional jump to 0x0e5a, if !msg.value label_0E56: // Incoming jump from 0x0E55, if not !msg.value // Inputs[1] { @0E59 memory[0x00:0x00] } 0E56 60 PUSH1 0x00 0E58 80 DUP1 0E59 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E59 revert(memory[0x00:0x00]); } // Block terminates label_0E5A: // Incoming jump from 0x0E55, if !msg.value // Inputs[1] { @0E62 msg.data.length } 0E5A 5B JUMPDEST 0E5B 50 POP 0E5C 61 PUSH2 0x0e9d 0E5F 60 PUSH1 0x04 0E61 80 DUP1 0E62 36 CALLDATASIZE 0E63 03 SUB 0E64 60 PUSH1 0x20 0E66 81 DUP2 0E67 10 LT 0E68 15 ISZERO 0E69 61 PUSH2 0x0e71 0E6C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0E5C stack[-1] = 0x0e9d // @0E5F stack[0] = 0x04 // @0E63 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0e71, returns to 0x0E9D, if !(msg.data.length - 0x04 < 0x20) label_0E6D: // Incoming jump from 0x0E6C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0E70 memory[0x00:0x00] } 0E6D 60 PUSH1 0x00 0E6F 80 DUP1 0E70 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E70 revert(memory[0x00:0x00]); } // Block terminates label_0E71: // Incoming call from 0x0E6C, returns to 0x0E9D, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0E72 stack[-2] // @0E73 stack[-1] // @0E77 msg.data[stack[-2]:stack[-2] + 0x20] // } 0E71 5B JUMPDEST 0E72 81 DUP2 0E73 01 ADD 0E74 90 SWAP1 0E75 80 DUP1 0E76 80 DUP1 0E77 35 CALLDATALOAD 0E78 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E8D 16 AND 0E8E 90 SWAP1 0E8F 60 PUSH1 0x20 0E91 01 ADD 0E92 90 SWAP1 0E93 92 SWAP3 0E94 91 SWAP2 0E95 90 SWAP1 0E96 50 POP 0E97 50 POP 0E98 50 POP 0E99 61 PUSH2 0x236a 0E9C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0E93 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x236a label_0E9D: // Incoming return from call to 0x0E71 at 0x0E6C // Inputs[4] // { // @0EA0 memory[0x40:0x60] // @0EA2 stack[-1] // @0EB1 memory[0x40:0x60] // @0EB6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E9D 5B JUMPDEST 0E9E 60 PUSH1 0x40 0EA0 51 MLOAD 0EA1 80 DUP1 0EA2 82 DUP3 0EA3 15 ISZERO 0EA4 15 ISZERO 0EA5 15 ISZERO 0EA6 15 ISZERO 0EA7 81 DUP2 0EA8 52 MSTORE 0EA9 60 PUSH1 0x20 0EAB 01 ADD 0EAC 91 SWAP2 0EAD 50 POP 0EAE 50 POP 0EAF 60 PUSH1 0x40 0EB1 51 MLOAD 0EB2 80 DUP1 0EB3 91 SWAP2 0EB4 03 SUB 0EB5 90 SWAP1 0EB6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0EA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0EB6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0EB7: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @0EB8 msg.value } 0EB7 5B JUMPDEST 0EB8 34 CALLVALUE 0EB9 80 DUP1 0EBA 15 ISZERO 0EBB 61 PUSH2 0x0ec3 0EBE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0EB8 stack[0] = msg.value } // Block ends with conditional jump to 0x0ec3, if !msg.value label_0EBF: // Incoming jump from 0x0EBE, if not !msg.value // Inputs[1] { @0EC2 memory[0x00:0x00] } 0EBF 60 PUSH1 0x00 0EC1 80 DUP1 0EC2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0EC2 revert(memory[0x00:0x00]); } // Block terminates label_0EC3: // Incoming jump from 0x0EBE, if !msg.value // Inputs[1] { @0ECB msg.data.length } 0EC3 5B JUMPDEST 0EC4 50 POP 0EC5 61 PUSH2 0x0f06 0EC8 60 PUSH1 0x04 0ECA 80 DUP1 0ECB 36 CALLDATASIZE 0ECC 03 SUB 0ECD 60 PUSH1 0x20 0ECF 81 DUP2 0ED0 10 LT 0ED1 15 ISZERO 0ED2 61 PUSH2 0x0eda 0ED5 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0EC5 stack[-1] = 0x0f06 // @0EC8 stack[0] = 0x04 // @0ECC stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0eda, returns to 0x0F06, if !(msg.data.length - 0x04 < 0x20) label_0ED6: // Incoming jump from 0x0ED5, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0ED9 memory[0x00:0x00] } 0ED6 60 PUSH1 0x00 0ED8 80 DUP1 0ED9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0ED9 revert(memory[0x00:0x00]); } // Block terminates label_0EDA: // Incoming call from 0x0ED5, returns to 0x0F06, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0EDB stack[-2] // @0EDC stack[-1] // @0EE0 msg.data[stack[-2]:stack[-2] + 0x20] // } 0EDA 5B JUMPDEST 0EDB 81 DUP2 0EDC 01 ADD 0EDD 90 SWAP1 0EDE 80 DUP1 0EDF 80 DUP1 0EE0 35 CALLDATALOAD 0EE1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EF6 16 AND 0EF7 90 SWAP1 0EF8 60 PUSH1 0x20 0EFA 01 ADD 0EFB 90 SWAP1 0EFC 92 SWAP3 0EFD 91 SWAP2 0EFE 90 SWAP1 0EFF 50 POP 0F00 50 POP 0F01 50 POP 0F02 61 PUSH2 0x2489 0F05 56 *JUMP // Stack delta = -1 // Outputs[1] { @0EFC stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2489 label_0F06: // Incoming return from call to 0x0EDA at 0x0ED5 0F06 5B JUMPDEST 0F07 00 *STOP // Stack delta = +0 // Outputs[1] { @0F07 stop(); } // Block terminates label_0F08: // Incoming call from 0x0295, returns to 0x0296 // Inputs[3] // { // @0F0E storage[0x00] // @0F2F memory[0x40:0x60] // @0F42 storage[0x00] // } 0F08 5B JUMPDEST 0F09 60 PUSH1 0x60 0F0B 60 PUSH1 0x00 0F0D 80 DUP1 0F0E 54 SLOAD 0F0F 60 PUSH1 0x01 0F11 81 DUP2 0F12 60 PUSH1 0x01 0F14 16 AND 0F15 15 ISZERO 0F16 61 PUSH2 0x0100 0F19 02 MUL 0F1A 03 SUB 0F1B 16 AND 0F1C 60 PUSH1 0x02 0F1E 90 SWAP1 0F1F 04 DIV 0F20 80 DUP1 0F21 60 PUSH1 0x1f 0F23 01 ADD 0F24 60 PUSH1 0x20 0F26 80 DUP1 0F27 91 SWAP2 0F28 04 DIV 0F29 02 MUL 0F2A 60 PUSH1 0x20 0F2C 01 ADD 0F2D 60 PUSH1 0x40 0F2F 51 MLOAD 0F30 90 SWAP1 0F31 81 DUP2 0F32 01 ADD 0F33 60 PUSH1 0x40 0F35 52 MSTORE 0F36 80 DUP1 0F37 92 SWAP3 0F38 91 SWAP2 0F39 90 SWAP1 0F3A 81 DUP2 0F3B 81 DUP2 0F3C 52 MSTORE 0F3D 60 PUSH1 0x20 0F3F 01 ADD 0F40 82 DUP3 0F41 80 DUP1 0F42 54 SLOAD 0F43 60 PUSH1 0x01 0F45 81 DUP2 0F46 60 PUSH1 0x01 0F48 16 AND 0F49 15 ISZERO 0F4A 61 PUSH2 0x0100 0F4D 02 MUL 0F4E 03 SUB 0F4F 16 AND 0F50 60 PUSH1 0x02 0F52 90 SWAP1 0F53 04 DIV 0F54 80 DUP1 0F55 15 ISZERO 0F56 61 PUSH2 0x0fa0 0F59 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0F09 stack[0] = 0x60 // @0F35 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) / 0x20 * 0x20 // @0F37 stack[1] = memory[0x40:0x60] // @0F38 stack[2] = 0x00 // @0F39 stack[3] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @0F3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @0F3F stack[4] = 0x20 + memory[0x40:0x60] // @0F40 stack[5] = 0x00 // @0F53 stack[6] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // } // Block ends with conditional jump to 0x0fa0, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) label_0F5A: // Incoming jump from 0x0F59, if not !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Inputs[1] { @0F5A stack[-1] } 0F5A 80 DUP1 0F5B 60 PUSH1 0x1f 0F5D 10 LT 0F5E 61 PUSH2 0x0f75 0F61 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f75, if 0x1f < stack[-1] label_0F62: // Incoming jump from 0x0F61, if not 0x1f < stack[-1] // Inputs[4] // { // @0F66 stack[-2] // @0F67 storage[stack[-2]] // @0F6A stack[-3] // @0F6C stack[-1] // } 0F62 61 PUSH2 0x0100 0F65 80 DUP1 0F66 83 DUP4 0F67 54 SLOAD 0F68 04 DIV 0F69 02 MUL 0F6A 83 DUP4 0F6B 52 MSTORE 0F6C 91 SWAP2 0F6D 60 PUSH1 0x20 0F6F 01 ADD 0F70 91 SWAP2 0F71 61 PUSH2 0x0fa0 0F74 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0F6B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0F70 stack[-1] = stack[-1] // @0F70 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0fa0 label_0F75: // Incoming jump from 0x0F61, if 0x1f < stack[-1] // Inputs[5] // { // @0F76 stack[-3] // @0F77 stack[-1] // @0F79 stack[-2] // @0F81 memory[0x00:0x20] // @0F85 storage[keccak256(memory[0x00:0x20])] // } 0F75 5B JUMPDEST 0F76 82 DUP3 0F77 01 ADD 0F78 91 SWAP2 0F79 90 SWAP1 0F7A 60 PUSH1 0x00 0F7C 52 MSTORE 0F7D 60 PUSH1 0x20 0F7F 60 PUSH1 0x00 0F81 20 SHA3 0F82 90 SWAP1 0F83 5B JUMPDEST 0F84 81 DUP2 0F85 54 SLOAD 0F86 81 DUP2 0F87 52 MSTORE 0F88 90 SWAP1 0F89 60 PUSH1 0x01 0F8B 01 ADD 0F8C 90 SWAP1 0F8D 60 PUSH1 0x20 0F8F 01 ADD 0F90 80 DUP1 0F91 83 DUP4 0F92 11 GT 0F93 61 PUSH2 0x0f83 0F96 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0F78 stack[-3] = stack[-3] + stack[-1] // @0F7C memory[0x00:0x20] = stack[-2] // @0F87 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0F8C stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0F8F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0f83, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0F97: // Incoming jump from 0x0F96, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0F96, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0F97 stack[-3] // @0F98 stack[-1] // } 0F97 82 DUP3 0F98 90 SWAP1 0F99 03 SUB 0F9A 60 PUSH1 0x1f 0F9C 16 AND 0F9D 82 DUP3 0F9E 01 ADD 0F9F 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0F9F stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0F9F stack[-1] = stack[-3] // } // Block continues label_0FA0: // Incoming jump from 0x0F74 // Incoming jump from 0x0F59, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Incoming jump from 0x0F9F // Inputs[3] // { // @0FA6 stack[-6] // @0FA6 stack[-7] // @0FA8 stack[-8] // } 0FA0 5B JUMPDEST 0FA1 50 POP 0FA2 50 POP 0FA3 50 POP 0FA4 50 POP 0FA5 50 POP 0FA6 90 SWAP1 0FA7 50 POP 0FA8 90 SWAP1 0FA9 56 *JUMP // Stack delta = -7 // Outputs[1] { @0FA8 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0FAA: // Incoming jump from 0x0369 // Inputs[1] { @0FC4 stack[-2] } 0FAA 5B JUMPDEST 0FAB 60 PUSH1 0x00 0FAD 80 DUP1 0FAE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FC3 16 AND 0FC4 83 DUP4 0FC5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FDA 16 AND 0FDB 14 EQ 0FDC 15 ISZERO 0FDD 61 PUSH2 0x0fe5 0FE0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0FAB stack[0] = 0x00 } // Block ends with conditional jump to 0x0fe5, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0FE1: // Incoming jump from 0x0FE0, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0FE4 memory[0x00:0x00] } 0FE1 60 PUSH1 0x00 0FE3 80 DUP1 0FE4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FE4 revert(memory[0x00:0x00]); } // Block terminates label_0FE5: // Incoming jump from 0x0FE0, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[11] // { // @0FE6 stack[-2] // @0FEB msg.sender // @1025 memory[0x00:0x40] // @1028 stack[-3] // @1062 memory[0x00:0x40] // @107E msg.sender // @10B9 memory[0x40:0x60] // @10C6 memory[0x40:0x60] // @10CB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @10CE stack[-1] // @10D0 stack[-4] // } 0FE5 5B JUMPDEST 0FE6 81 DUP2 0FE7 60 PUSH1 0x04 0FE9 60 PUSH1 0x00 0FEB 33 CALLER 0FEC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1001 16 AND 1002 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1017 16 AND 1018 81 DUP2 1019 52 MSTORE 101A 60 PUSH1 0x20 101C 01 ADD 101D 90 SWAP1 101E 81 DUP2 101F 52 MSTORE 1020 60 PUSH1 0x20 1022 01 ADD 1023 60 PUSH1 0x00 1025 20 SHA3 1026 60 PUSH1 0x00 1028 85 DUP6 1029 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 103E 16 AND 103F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1054 16 AND 1055 81 DUP2 1056 52 MSTORE 1057 60 PUSH1 0x20 1059 01 ADD 105A 90 SWAP1 105B 81 DUP2 105C 52 MSTORE 105D 60 PUSH1 0x20 105F 01 ADD 1060 60 PUSH1 0x00 1062 20 SHA3 1063 81 DUP2 1064 90 SWAP1 1065 55 SSTORE 1066 50 POP 1067 82 DUP3 1068 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 107D 16 AND 107E 33 CALLER 107F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1094 16 AND 1095 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 10B6 84 DUP5 10B7 60 PUSH1 0x40 10B9 51 MLOAD 10BA 80 DUP1 10BB 82 DUP3 10BC 81 DUP2 10BD 52 MSTORE 10BE 60 PUSH1 0x20 10C0 01 ADD 10C1 91 SWAP2 10C2 50 POP 10C3 50 POP 10C4 60 PUSH1 0x40 10C6 51 MLOAD 10C7 80 DUP1 10C8 91 SWAP2 10C9 03 SUB 10CA 90 SWAP1 10CB A3 LOG3 10CC 60 PUSH1 0x01 10CE 90 SWAP1 10CF 50 POP 10D0 92 SWAP3 10D1 91 SWAP2 10D2 50 POP 10D3 50 POP 10D4 56 *JUMP // Stack delta = -3 // Outputs[8] // { // @1019 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @101F memory[0x20:0x40] = 0x04 // @1056 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @105C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1065 storage[keccak256(memory[0x00:0x40])] = stack[-2] // @10BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @10CB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // @10D0 stack[-4] = 0x01 // } // Block ends with unconditional jump to stack[-4] label_10D5: // Incoming call from 0x0398, returns to 0x0399 // Inputs[2] // { // @10DA storage[0x05] // @10DD stack[-1] // } 10D5 5B JUMPDEST 10D6 60 PUSH1 0x00 10D8 60 PUSH1 0x05 10DA 54 SLOAD 10DB 90 SWAP1 10DC 50 POP 10DD 90 SWAP1 10DE 56 *JUMP // Stack delta = +0 // Outputs[1] { @10DD stack[-1] = storage[0x05] } // Block ends with unconditional jump to stack[-1] label_10DF: // Incoming jump from 0x0427 // Inputs[3] // { // @10E2 stack[-3] // @1121 memory[0x00:0x40] // @1125 storage[keccak256(memory[0x00:0x40])] // } 10DF 5B JUMPDEST 10E0 60 PUSH1 0x00 10E2 83 DUP4 10E3 60 PUSH1 0x0b 10E5 60 PUSH1 0x00 10E7 82 DUP3 10E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10FD 16 AND 10FE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1113 16 AND 1114 81 DUP2 1115 52 MSTORE 1116 60 PUSH1 0x20 1118 01 ADD 1119 90 SWAP1 111A 81 DUP2 111B 52 MSTORE 111C 60 PUSH1 0x20 111E 01 ADD 111F 60 PUSH1 0x00 1121 20 SHA3 1122 60 PUSH1 0x00 1124 90 SWAP1 1125 54 SLOAD 1126 90 SWAP1 1127 61 PUSH2 0x0100 112A 0A EXP 112B 90 SWAP1 112C 04 DIV 112D 60 PUSH1 0xff 112F 16 AND 1130 15 ISZERO 1131 61 PUSH2 0x1139 1134 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @10E0 stack[0] = 0x00 // @10E2 stack[1] = stack[-3] // @1115 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @111B memory[0x20:0x40] = 0x0b // } // Block ends with conditional jump to 0x1139, if !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) label_1135: // Incoming jump from 0x1134, if not !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[1] { @1138 memory[0x00:0x00] } 1135 60 PUSH1 0x00 1137 80 DUP1 1138 FD *REVERT // Stack delta = +0 // Outputs[1] { @1138 revert(memory[0x00:0x00]); } // Block terminates label_1139: // Incoming jump from 0x1134, if !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[3] // { // @1140 stack[-5] // @117A memory[0x00:0x40] // @117C storage[keccak256(memory[0x00:0x40])] // } 1139 5B JUMPDEST 113A 60 PUSH1 0x00 113C 60 PUSH1 0x0a 113E 60 PUSH1 0x00 1140 87 DUP8 1141 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1156 16 AND 1157 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 116C 16 AND 116D 81 DUP2 116E 52 MSTORE 116F 60 PUSH1 0x20 1171 01 ADD 1172 90 SWAP1 1173 81 DUP2 1174 52 MSTORE 1175 60 PUSH1 0x20 1177 01 ADD 1178 60 PUSH1 0x00 117A 20 SHA3 117B 80 DUP1 117C 54 SLOAD 117D 90 SWAP1 117E 50 POP 117F 11 GT 1180 15 ISZERO 1181 61 PUSH2 0x118f 1184 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @116E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1174 memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x118f, if !(storage[keccak256(memory[0x00:0x40])] > 0x00) label_1185: // Incoming jump from 0x1184, if not !(storage[keccak256(memory[0x00:0x40])] > 0x00) // Inputs[1] { @1188 stack[-5] } 1185 61 PUSH2 0x118d 1188 85 DUP6 1189 61 PUSH2 0x2561 118C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1185 stack[0] = 0x118d // @1188 stack[1] = stack[-5] // } // Block ends with call to 0x2561, returns to 0x118D label_118D: // Incoming return from call to 0x2561 at 0x118C 118D 5B JUMPDEST 118E 50 POP // Stack delta = -1 // Block continues label_118F: // Incoming jump from 0x118E // Incoming jump from 0x1184, if !(storage[keccak256(memory[0x00:0x40])] > 0x00) // Inputs[3] // { // @1193 stack[-5] // @1194 stack[-4] // @1195 stack[-3] // } 118F 5B JUMPDEST 1190 61 PUSH2 0x119a 1193 85 DUP6 1194 85 DUP6 1195 85 DUP6 1196 61 PUSH2 0x2643 1199 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1190 stack[0] = 0x119a // @1193 stack[1] = stack[-5] // @1194 stack[2] = stack[-4] // @1195 stack[3] = stack[-3] // } // Block ends with call to 0x2643, returns to 0x119A label_119A: // Incoming return from call to 0x2643 at 0x1199 // Inputs[4] // { // @119B stack[-1] // @119B stack[-3] // @119E stack[-7] // @119F stack[-6] // } 119A 5B JUMPDEST 119B 91 SWAP2 119C 50 POP 119D 50 POP 119E 93 SWAP4 119F 92 SWAP3 11A0 50 POP 11A1 50 POP 11A2 50 POP 11A3 56 *JUMP // Stack delta = -6 // Outputs[1] { @119E stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_11A4: // Incoming call from 0x1CE1, returns to 0x1CE2 // Incoming call from 0x1C43, returns to 0x1C44 // Incoming jump from 0x0490 // Incoming call from 0x22B0, returns to 0x22B1 // Incoming call from 0x185C, returns to 0x185D // Incoming call from 0x1B55, returns to 0x1B56 // Incoming call from 0x2383, returns to 0x2384 // Incoming call from 0x226A, returns to 0x226B // Incoming call from 0x1533, returns to 0x1534 // Inputs[2] // { // @11AC storage[0x06] // @11E0 stack[-1] // } 11A4 5B JUMPDEST 11A5 60 PUSH1 0x00 11A7 60 PUSH1 0x06 11A9 60 PUSH1 0x00 11AB 90 SWAP1 11AC 54 SLOAD 11AD 90 SWAP1 11AE 61 PUSH2 0x0100 11B1 0A EXP 11B2 90 SWAP1 11B3 04 DIV 11B4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11C9 16 AND 11CA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11DF 16 AND 11E0 82 DUP3 11E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11F6 16 AND 11F7 14 EQ 11F8 15 ISZERO 11F9 61 PUSH2 0x1205 11FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @11A5 stack[0] = 0x00 } // Block ends with conditional jump to 0x1205, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00) label_11FD: // Incoming jump from 0x11FC, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00) // Inputs[1] { @11FF stack[-1] } 11FD 60 PUSH1 0x01 11FF 90 SWAP1 1200 50 POP 1201 61 PUSH2 0x120a 1204 56 *JUMP // Stack delta = +0 // Outputs[1] { @11FF stack[-1] = 0x01 } // Block ends with unconditional jump to 0x120a label_1205: // Incoming jump from 0x11FC, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00) // Inputs[3] // { // @1208 stack[-1] // @120B stack[-3] // @120C stack[-2] // } 1205 5B JUMPDEST 1206 60 PUSH1 0x00 1208 90 SWAP1 1209 50 POP 120A 5B JUMPDEST 120B 91 SWAP2 120C 90 SWAP1 120D 50 POP 120E 56 *JUMP // Stack delta = -2 // Outputs[1] { @120B stack[-3] = 0x00 } // Block ends with unconditional jump to stack[-3] label_120F: // Incoming call from 0x04BF, returns to 0x04C0 // Inputs[2] // { // @1217 storage[0x02] // @1224 stack[-1] // } 120F 5B JUMPDEST 1210 60 PUSH1 0x00 1212 60 PUSH1 0x02 1214 60 PUSH1 0x00 1216 90 SWAP1 1217 54 SLOAD 1218 90 SWAP1 1219 61 PUSH2 0x0100 121C 0A EXP 121D 90 SWAP1 121E 04 DIV 121F 60 PUSH1 0xff 1221 16 AND 1222 90 SWAP1 1223 50 POP 1224 90 SWAP1 1225 56 *JUMP // Stack delta = +0 // Outputs[1] { @1224 stack[-1] = 0xff & storage[0x02] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_1226: // Incoming jump from 0x052A // Inputs[2] // { // @122C storage[0x06] // @1260 msg.sender // } 1226 5B JUMPDEST 1227 60 PUSH1 0x06 1229 60 PUSH1 0x00 122B 90 SWAP1 122C 54 SLOAD 122D 90 SWAP1 122E 61 PUSH2 0x0100 1231 0A EXP 1232 90 SWAP1 1233 04 DIV 1234 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1249 16 AND 124A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 125F 16 AND 1260 33 CALLER 1261 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1276 16 AND 1277 14 EQ 1278 61 PUSH2 0x1280 127B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1280, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 label_127C: // Incoming jump from 0x127B, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 // Inputs[1] { @127F memory[0x00:0x00] } 127C 60 PUSH1 0x00 127E 80 DUP1 127F FD *REVERT // Stack delta = +0 // Outputs[1] { @127F revert(memory[0x00:0x00]); } // Block terminates label_1280: // Incoming jump from 0x127B, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 // Inputs[2] // { // @1281 stack[-1] // @129D storage[0x09] // } 1280 5B JUMPDEST 1281 80 DUP1 1282 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1297 16 AND 1298 60 PUSH1 0x09 129A 60 PUSH1 0x01 129C 90 SWAP1 129D 54 SLOAD 129E 90 SWAP1 129F 61 PUSH2 0x0100 12A2 0A EXP 12A3 90 SWAP1 12A4 04 DIV 12A5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12BA 16 AND 12BB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12D0 16 AND 12D1 14 EQ 12D2 15 ISZERO 12D3 61 PUSH2 0x12db 12D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12db, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x09] / 0x0100 ** 0x01 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_12D7: // Incoming jump from 0x12D6, if not !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x09] / 0x0100 ** 0x01 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @12DA memory[0x00:0x00] } 12D7 60 PUSH1 0x00 12D9 80 DUP1 12DA FD *REVERT // Stack delta = +0 // Outputs[1] { @12DA revert(memory[0x00:0x00]); } // Block terminates label_12DB: // Incoming jump from 0x12D6, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x09] / 0x0100 ** 0x01 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @12DF stack[-1] } 12DB 5B JUMPDEST 12DC 61 PUSH2 0x12e4 12DF 81 DUP2 12E0 61 PUSH2 0x2673 12E3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12DC stack[0] = 0x12e4 // @12DF stack[1] = stack[-1] // } // Block ends with call to 0x2673, returns to 0x12E4 label_12E4: // Incoming return from call to 0x2673 at 0x12E3 // Inputs[1] { @12E6 stack[-2] } 12E4 5B JUMPDEST 12E5 50 POP 12E6 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_12E7: // Incoming jump from 0x0585 // Inputs[1] { @1301 stack[-2] } 12E7 5B JUMPDEST 12E8 60 PUSH1 0x00 12EA 80 DUP1 12EB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1300 16 AND 1301 83 DUP4 1302 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1317 16 AND 1318 14 EQ 1319 15 ISZERO 131A 61 PUSH2 0x1322 131D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12E8 stack[0] = 0x00 } // Block ends with conditional jump to 0x1322, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_131E: // Incoming jump from 0x131D, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1321 memory[0x00:0x00] } 131E 60 PUSH1 0x00 1320 80 DUP1 1321 FD *REVERT // Stack delta = +0 // Outputs[1] { @1321 revert(memory[0x00:0x00]); } // Block terminates label_1322: // Incoming jump from 0x131D, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @1326 stack[-2] // @132B msg.sender // @1365 memory[0x00:0x40] // @1368 stack[-3] // @13A2 memory[0x00:0x40] // @13A3 storage[keccak256(memory[0x00:0x40])] // } 1322 5B JUMPDEST 1323 61 PUSH2 0x13b1 1326 82 DUP3 1327 60 PUSH1 0x04 1329 60 PUSH1 0x00 132B 33 CALLER 132C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1341 16 AND 1342 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1357 16 AND 1358 81 DUP2 1359 52 MSTORE 135A 60 PUSH1 0x20 135C 01 ADD 135D 90 SWAP1 135E 81 DUP2 135F 52 MSTORE 1360 60 PUSH1 0x20 1362 01 ADD 1363 60 PUSH1 0x00 1365 20 SHA3 1366 60 PUSH1 0x00 1368 86 DUP7 1369 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 137E 16 AND 137F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1394 16 AND 1395 81 DUP2 1396 52 MSTORE 1397 60 PUSH1 0x20 1399 01 ADD 139A 90 SWAP1 139B 81 DUP2 139C 52 MSTORE 139D 60 PUSH1 0x20 139F 01 ADD 13A0 60 PUSH1 0x00 13A2 20 SHA3 13A3 54 SLOAD 13A4 61 PUSH2 0x26b7 13A7 90 SWAP1 13A8 91 SWAP2 13A9 90 SWAP1 13AA 63 PUSH4 0xffffffff 13AF 16 AND 13B0 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @1323 stack[0] = 0x13b1 // @1359 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @135F memory[0x20:0x40] = 0x04 // @1396 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @139C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @13A8 stack[1] = storage[keccak256(memory[0x00:0x40])] // @13A9 stack[2] = stack[-2] // } // Block ends with call to 0xffffffff & 0x26b7, returns to 0x13B1 label_13B1: // Incoming return from call to 0x26B7 at 0x13B0 // Inputs[15] // { // @13B6 msg.sender // @13F0 memory[0x00:0x40] // @13F3 stack[-4] // @142D memory[0x00:0x40] // @142E stack[-1] // @1449 msg.sender // @1485 msg.sender // @14BF memory[0x00:0x40] // @14FC memory[0x00:0x40] // @14FD storage[keccak256(memory[0x00:0x40])] // @1500 memory[0x40:0x60] // @150D memory[0x40:0x60] // @1512 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1515 stack[-2] // @1517 stack[-5] // } 13B1 5B JUMPDEST 13B2 60 PUSH1 0x04 13B4 60 PUSH1 0x00 13B6 33 CALLER 13B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13CC 16 AND 13CD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13E2 16 AND 13E3 81 DUP2 13E4 52 MSTORE 13E5 60 PUSH1 0x20 13E7 01 ADD 13E8 90 SWAP1 13E9 81 DUP2 13EA 52 MSTORE 13EB 60 PUSH1 0x20 13ED 01 ADD 13EE 60 PUSH1 0x00 13F0 20 SHA3 13F1 60 PUSH1 0x00 13F3 85 DUP6 13F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1409 16 AND 140A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 141F 16 AND 1420 81 DUP2 1421 52 MSTORE 1422 60 PUSH1 0x20 1424 01 ADD 1425 90 SWAP1 1426 81 DUP2 1427 52 MSTORE 1428 60 PUSH1 0x20 142A 01 ADD 142B 60 PUSH1 0x00 142D 20 SHA3 142E 81 DUP2 142F 90 SWAP1 1430 55 SSTORE 1431 50 POP 1432 82 DUP3 1433 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1448 16 AND 1449 33 CALLER 144A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 145F 16 AND 1460 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1481 60 PUSH1 0x04 1483 60 PUSH1 0x00 1485 33 CALLER 1486 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 149B 16 AND 149C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14B1 16 AND 14B2 81 DUP2 14B3 52 MSTORE 14B4 60 PUSH1 0x20 14B6 01 ADD 14B7 90 SWAP1 14B8 81 DUP2 14B9 52 MSTORE 14BA 60 PUSH1 0x20 14BC 01 ADD 14BD 60 PUSH1 0x00 14BF 20 SHA3 14C0 60 PUSH1 0x00 14C2 87 DUP8 14C3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14D8 16 AND 14D9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14EE 16 AND 14EF 81 DUP2 14F0 52 MSTORE 14F1 60 PUSH1 0x20 14F3 01 ADD 14F4 90 SWAP1 14F5 81 DUP2 14F6 52 MSTORE 14F7 60 PUSH1 0x20 14F9 01 ADD 14FA 60 PUSH1 0x00 14FC 20 SHA3 14FD 54 SLOAD 14FE 60 PUSH1 0x40 1500 51 MLOAD 1501 80 DUP1 1502 82 DUP3 1503 81 DUP2 1504 52 MSTORE 1505 60 PUSH1 0x20 1507 01 ADD 1508 91 SWAP2 1509 50 POP 150A 50 POP 150B 60 PUSH1 0x40 150D 51 MLOAD 150E 80 DUP1 150F 91 SWAP2 1510 03 SUB 1511 90 SWAP1 1512 A3 LOG3 1513 60 PUSH1 0x01 1515 90 SWAP1 1516 50 POP 1517 92 SWAP3 1518 91 SWAP2 1519 50 POP 151A 50 POP 151B 56 *JUMP // Stack delta = -4 // Outputs[12] // { // @13E4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @13EA memory[0x20:0x40] = 0x04 // @1421 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1427 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1430 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @14B3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @14B9 memory[0x20:0x40] = 0x04 // @14F0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @14F6 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1504 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @1512 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @1517 stack[-5] = 0x01 // } // Block ends with unconditional jump to stack[-5] label_151C: // Incoming call from 0x05B4, returns to 0x05B5 // Inputs[1] { @1520 msg.sender } 151C 5B JUMPDEST 151D 61 PUSH2 0x1525 1520 33 CALLER 1521 61 PUSH2 0x1647 1524 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @151D stack[0] = 0x1525 // @1520 stack[1] = msg.sender // } // Block ends with call to 0x1647, returns to 0x1525 label_1525: // Incoming return from call to 0x1647 at 0x1524 // Inputs[1] { @1526 stack[-1] } 1525 5B JUMPDEST 1526 80 DUP1 1527 61 PUSH2 0x1535 152A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1535, if stack[-1] label_152B: // Incoming jump from 0x152A, if not stack[-1] // Inputs[1] { @152F msg.sender } 152B 50 POP 152C 61 PUSH2 0x1534 152F 33 CALLER 1530 61 PUSH2 0x11a4 1533 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @152C stack[-1] = 0x1534 // @152F stack[0] = msg.sender // } // Block ends with call to 0x11a4, returns to 0x1534 label_1534: // Incoming return from call to 0x11A4 at 0x1533 1534 5B JUMPDEST // Stack delta = +0 // Block continues label_1535: // Incoming jump from 0x1534 // Incoming jump from 0x152A, if stack[-1] // Inputs[1] { @1539 stack[-1] } 1535 5B JUMPDEST 1536 61 PUSH2 0x153e 1539 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x153e, if stack[-1] label_153A: // Incoming jump from 0x1539, if not stack[-1] // Inputs[1] { @153D memory[0x00:0x00] } 153A 60 PUSH1 0x00 153C 80 DUP1 153D FD *REVERT // Stack delta = +0 // Outputs[1] { @153D revert(memory[0x00:0x00]); } // Block terminates label_153E: // Incoming jump from 0x1539, if stack[-1] // Inputs[1] { @1544 storage[0x09] } 153E 5B JUMPDEST 153F 60 PUSH1 0x09 1541 60 PUSH1 0x00 1543 90 SWAP1 1544 54 SLOAD 1545 90 SWAP1 1546 61 PUSH2 0x0100 1549 0A EXP 154A 90 SWAP1 154B 04 DIV 154C 60 PUSH1 0xff 154E 16 AND 154F 61 PUSH2 0x1557 1552 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1557, if 0xff & storage[0x09] / 0x0100 ** 0x00 label_1553: // Incoming jump from 0x1552, if not 0xff & storage[0x09] / 0x0100 ** 0x00 // Inputs[1] { @1556 memory[0x00:0x00] } 1553 60 PUSH1 0x00 1555 80 DUP1 1556 FD *REVERT // Stack delta = +0 // Outputs[1] { @1556 revert(memory[0x00:0x00]); } // Block terminates label_1557: // Incoming jump from 0x1552, if 0xff & storage[0x09] / 0x0100 ** 0x00 // Inputs[6] // { // @1563 storage[0x09] // @1594 msg.sender // @1597 memory[0x40:0x60] // @15D0 memory[0x40:0x60] // @15D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @15D6 stack[-1] // } 1557 5B JUMPDEST 1558 60 PUSH1 0x00 155A 60 PUSH1 0x09 155C 60 PUSH1 0x00 155E 61 PUSH2 0x0100 1561 0A EXP 1562 81 DUP2 1563 54 SLOAD 1564 81 DUP2 1565 60 PUSH1 0xff 1567 02 MUL 1568 19 NOT 1569 16 AND 156A 90 SWAP1 156B 83 DUP4 156C 15 ISZERO 156D 15 ISZERO 156E 02 MUL 156F 17 OR 1570 90 SWAP1 1571 55 SSTORE 1572 50 POP 1573 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 1594 33 CALLER 1595 60 PUSH1 0x40 1597 51 MLOAD 1598 80 DUP1 1599 82 DUP3 159A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15AF 16 AND 15B0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15C5 16 AND 15C6 81 DUP2 15C7 52 MSTORE 15C8 60 PUSH1 0x20 15CA 01 ADD 15CB 91 SWAP2 15CC 50 POP 15CD 50 POP 15CE 60 PUSH1 0x40 15D0 51 MLOAD 15D1 80 DUP1 15D2 91 SWAP2 15D3 03 SUB 15D4 90 SWAP1 15D5 A1 LOG1 15D6 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1571 storage[0x09] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x09]) // @15C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @15D5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa]); // } // Block ends with unconditional jump to stack[-1] label_15D7: // Incoming jump from 0x060F // Inputs[2] // { // @15DF storage[0x06] // @1613 msg.sender // } 15D7 5B JUMPDEST 15D8 60 PUSH1 0x00 15DA 60 PUSH1 0x06 15DC 60 PUSH1 0x00 15DE 90 SWAP1 15DF 54 SLOAD 15E0 90 SWAP1 15E1 61 PUSH2 0x0100 15E4 0A EXP 15E5 90 SWAP1 15E6 04 DIV 15E7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15FC 16 AND 15FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1612 16 AND 1613 33 CALLER 1614 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1629 16 AND 162A 14 EQ 162B 61 PUSH2 0x1633 162E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15D8 stack[0] = 0x00 } // Block ends with conditional jump to 0x1633, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 label_162F: // Incoming jump from 0x162E, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 // Inputs[1] { @1632 memory[0x00:0x00] } 162F 60 PUSH1 0x00 1631 80 DUP1 1632 FD *REVERT // Stack delta = +0 // Outputs[1] { @1632 revert(memory[0x00:0x00]); } // Block terminates label_1633: // Incoming jump from 0x162E, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 // Inputs[2] // { // @1637 stack[-3] // @1638 stack[-2] // } 1633 5B JUMPDEST 1634 61 PUSH2 0x163d 1637 83 DUP4 1638 83 DUP4 1639 61 PUSH2 0x26d6 163C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1634 stack[0] = 0x163d // @1637 stack[1] = stack[-3] // @1638 stack[2] = stack[-2] // } // Block ends with call to 0x26d6, returns to 0x163D label_163D: // Incoming return from call to 0x26D6 at 0x163C // Inputs[3] // { // @1640 stack[-1] // @1642 stack[-4] // @1643 stack[-3] // } 163D 5B JUMPDEST 163E 60 PUSH1 0x01 1640 90 SWAP1 1641 50 POP 1642 92 SWAP3 1643 91 SWAP2 1644 50 POP 1645 50 POP 1646 56 *JUMP // Stack delta = -3 // Outputs[1] { @1642 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_1647: // Incoming call from 0x184D, returns to 0x184E // Incoming call from 0x2374, returns to 0x2375 // Incoming call from 0x22A1, returns to 0x22A2 // Incoming jump from 0x0678 // Incoming call from 0x225B, returns to 0x225C // Incoming call from 0x1CD2, returns to 0x1CD3 // Incoming call from 0x1C34, returns to 0x1C35 // Incoming call from 0x1B46, returns to 0x1B47 // Incoming call from 0x1524, returns to 0x1525 // Inputs[1] { @164D stack[-1] } 1647 5B JUMPDEST 1648 60 PUSH1 0x00 164A 61 PUSH2 0x165d 164D 82 DUP3 164E 60 PUSH1 0x08 1650 61 PUSH2 0x282a 1653 90 SWAP1 1654 91 SWAP2 1655 90 SWAP1 1656 63 PUSH4 0xffffffff 165B 16 AND 165C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1648 stack[0] = 0x00 // @164A stack[1] = 0x165d // @1654 stack[2] = 0x08 // @1655 stack[3] = stack[-1] // } // Block ends with call to 0xffffffff & 0x282a, returns to 0x165D label_165D: // Incoming return from call to 0x282A at 0x165C // Inputs[4] // { // @165E stack[-2] // @165E stack[-1] // @1660 stack[-4] // @1661 stack[-3] // } 165D 5B JUMPDEST 165E 90 SWAP1 165F 50 POP 1660 91 SWAP2 1661 90 SWAP1 1662 50 POP 1663 56 *JUMP // Stack delta = -3 // Outputs[1] { @1660 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1664: // Incoming call from 0x06A7, returns to 0x06A8 // Inputs[2] // { // @166A storage[0x09] // @1688 stack[-1] // } 1664 5B JUMPDEST 1665 60 PUSH1 0x09 1667 60 PUSH1 0x01 1669 90 SWAP1 166A 54 SLOAD 166B 90 SWAP1 166C 61 PUSH2 0x0100 166F 0A EXP 1670 90 SWAP1 1671 04 DIV 1672 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1687 16 AND 1688 81 DUP2 1689 56 *JUMP // Stack delta = +1 // Outputs[1] { @1687 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x09] / 0x0100 ** 0x01 } // Block ends with unconditional jump to stack[-1] label_168A: // Incoming call from 0x06FE, returns to 0x06FF // Inputs[2] // { // @1692 storage[0x09] // @169F stack[-1] // } 168A 5B JUMPDEST 168B 60 PUSH1 0x00 168D 60 PUSH1 0x09 168F 60 PUSH1 0x00 1691 90 SWAP1 1692 54 SLOAD 1693 90 SWAP1 1694 61 PUSH2 0x0100 1697 0A EXP 1698 90 SWAP1 1699 04 DIV 169A 60 PUSH1 0xff 169C 16 AND 169D 90 SWAP1 169E 50 POP 169F 90 SWAP1 16A0 56 *JUMP // Stack delta = +0 // Outputs[1] { @169F stack[-1] = 0xff & storage[0x09] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_16A1: // Incoming jump from 0x0767 // Inputs[2] // { // @16A7 storage[0x06] // @16DB msg.sender // } 16A1 5B JUMPDEST 16A2 60 PUSH1 0x06 16A4 60 PUSH1 0x00 16A6 90 SWAP1 16A7 54 SLOAD 16A8 90 SWAP1 16A9 61 PUSH2 0x0100 16AC 0A EXP 16AD 90 SWAP1 16AE 04 DIV 16AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16C4 16 AND 16C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16DA 16 AND 16DB 33 CALLER 16DC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16F1 16 AND 16F2 14 EQ 16F3 61 PUSH2 0x16fb 16F6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16fb, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 label_16F7: // Incoming jump from 0x16F6, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 // Inputs[1] { @16FA memory[0x00:0x00] } 16F7 60 PUSH1 0x00 16F9 80 DUP1 16FA FD *REVERT // Stack delta = +0 // Outputs[1] { @16FA revert(memory[0x00:0x00]); } // Block terminates label_16FB: // Incoming jump from 0x16F6, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 // Inputs[1] { @16FF stack[-1] } 16FB 5B JUMPDEST 16FC 61 PUSH2 0x1704 16FF 81 DUP2 1700 61 PUSH2 0x28bc 1703 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @16FC stack[0] = 0x1704 // @16FF stack[1] = stack[-1] // } // Block ends with call to 0x28bc, returns to 0x1704 label_1704: // Incoming return from call to 0x28BC at 0x1703 // Inputs[1] { @1706 stack[-2] } 1704 5B JUMPDEST 1705 50 POP 1706 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1707: // Incoming call from 0x077E, returns to 0x077F // Inputs[1] { @170B msg.sender } 1707 5B JUMPDEST 1708 61 PUSH2 0x1710 170B 33 CALLER 170C 61 PUSH2 0x28bc 170F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1708 stack[0] = 0x1710 // @170B stack[1] = msg.sender // } // Block ends with call to 0x28bc, returns to 0x1710 label_1710: // Incoming return from call to 0x28BC at 0x170F // Inputs[1] { @1711 stack[-1] } 1710 5B JUMPDEST 1711 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_1712: // Incoming jump from 0x07CF // Inputs[1] { @1719 stack[-1] } 1712 5B JUMPDEST 1713 60 PUSH1 0x00 1715 80 DUP1 1716 61 PUSH2 0x171e 1719 83 DUP4 171A 61 PUSH2 0x2916 171D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1713 stack[0] = 0x00 // @1715 stack[1] = 0x00 // @1716 stack[2] = 0x171e // @1719 stack[3] = stack[-1] // } // Block ends with call to 0x2916, returns to 0x171E label_171E: // Incoming return from call to 0x2916 at 0x171D // Inputs[5] // { // @171F stack[-2] // @171F stack[-1] // @1727 stack[-4] // @1761 memory[0x00:0x40] // @1763 storage[keccak256(memory[0x00:0x40])] // } 171E 5B JUMPDEST 171F 90 SWAP1 1720 50 POP 1721 60 PUSH1 0x00 1723 60 PUSH1 0x0a 1725 60 PUSH1 0x00 1727 85 DUP6 1728 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 173D 16 AND 173E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1753 16 AND 1754 81 DUP2 1755 52 MSTORE 1756 60 PUSH1 0x20 1758 01 ADD 1759 90 SWAP1 175A 81 DUP2 175B 52 MSTORE 175C 60 PUSH1 0x20 175E 01 ADD 175F 60 PUSH1 0x00 1761 20 SHA3 1762 80 DUP1 1763 54 SLOAD 1764 90 SWAP1 1765 50 POP 1766 11 GT 1767 15 ISZERO 1768 61 PUSH2 0x183a 176B 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @171F stack[-2] = stack[-1] // @1755 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @175B memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x183a, if !(storage[keccak256(memory[0x00:0x40])] > 0x00) label_176C: // Incoming jump from 0x176B, if not !(storage[keccak256(memory[0x00:0x40])] > 0x00) // Inputs[3] // { // @1776 stack[-3] // @17B0 memory[0x00:0x40] // @17B2 storage[keccak256(memory[0x00:0x40])] // } 176C 60 PUSH1 0x00 176E 80 DUP1 176F 90 SWAP1 1770 50 POP 1771 5B JUMPDEST 1772 60 PUSH1 0x0a 1774 60 PUSH1 0x00 1776 85 DUP6 1777 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 178C 16 AND 178D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17A2 16 AND 17A3 81 DUP2 17A4 52 MSTORE 17A5 60 PUSH1 0x20 17A7 01 ADD 17A8 90 SWAP1 17A9 81 DUP2 17AA 52 MSTORE 17AB 60 PUSH1 0x20 17AD 01 ADD 17AE 60 PUSH1 0x00 17B0 20 SHA3 17B1 80 DUP1 17B2 54 SLOAD 17B3 90 SWAP1 17B4 50 POP 17B5 81 DUP2 17B6 10 LT 17B7 15 ISZERO 17B8 61 PUSH2 0x1838 17BB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @176F stack[0] = 0x00 // @17A4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @17AA memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x1838, if !(0x00 < storage[keccak256(memory[0x00:0x40])]) label_17BC: // Incoming jump from 0x17BB, if not !(0x00 < storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x17BB, if not !(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @17C3 stack[-4] // @17FD memory[0x00:0x40] // @17FE stack[-1] // @1800 storage[keccak256(memory[0x00:0x40])] // } 17BC 61 PUSH2 0x1829 17BF 60 PUSH1 0x0a 17C1 60 PUSH1 0x00 17C3 86 DUP7 17C4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17D9 16 AND 17DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17EF 16 AND 17F0 81 DUP2 17F1 52 MSTORE 17F2 60 PUSH1 0x20 17F4 01 ADD 17F5 90 SWAP1 17F6 81 DUP2 17F7 52 MSTORE 17F8 60 PUSH1 0x20 17FA 01 ADD 17FB 60 PUSH1 0x00 17FD 20 SHA3 17FE 82 DUP3 17FF 81 DUP2 1800 54 SLOAD 1801 81 DUP2 1802 10 LT 1803 61 PUSH2 0x1808 1806 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @17BC stack[0] = 0x1829 // @17F1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @17F7 memory[0x20:0x40] = 0x0a // @17FD stack[1] = keccak256(memory[0x00:0x40]) // @17FE stack[2] = stack[-1] // } // Block ends with conditional call to 0x1808, returns to 0x1829, if stack[-1] < storage[keccak256(memory[0x00:0x40])] label_1807: // Incoming jump from 0x1806, if not stack[-1] < storage[keccak256(memory[0x00:0x40])] 1807 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1807 assert(); } // Block terminates label_1808: // Incoming call from 0x1806, returns to 0x1829, if stack[-1] < storage[keccak256(memory[0x00:0x40])] // Inputs[5] // { // @1809 stack[-1] // @1809 stack[-2] // @1811 memory[0x00:0x20] // @181A storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @181B stack[-5] // } 1808 5B JUMPDEST 1809 90 SWAP1 180A 60 PUSH1 0x00 180C 52 MSTORE 180D 60 PUSH1 0x20 180F 60 PUSH1 0x00 1811 20 SHA3 1812 90 SWAP1 1813 60 PUSH1 0x02 1815 02 MUL 1816 01 ADD 1817 60 PUSH1 0x01 1819 01 ADD 181A 54 SLOAD 181B 83 DUP4 181C 61 PUSH2 0x26b7 181F 90 SWAP1 1820 91 SWAP2 1821 90 SWAP1 1822 63 PUSH4 0xffffffff 1827 16 AND 1828 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @180C memory[0x00:0x20] = stack[-2] // @1820 stack[-2] = stack[-5] // @1821 stack[-1] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // } // Block ends with unconditional jump to 0xffffffff & 0x26b7 label_1829: // Incoming return from call to 0x1808 at 0x1806 // Inputs[3] // { // @182A stack[-1] // @182A stack[-3] // @182C stack[-2] // } 1829 5B JUMPDEST 182A 91 SWAP2 182B 50 POP 182C 80 DUP1 182D 80 DUP1 182E 60 PUSH1 0x01 1830 01 ADD 1831 91 SWAP2 1832 50 POP 1833 50 POP 1834 61 PUSH2 0x1771 1837 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @182A stack[-3] = stack[-1] // @1831 stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x1771 label_1838: // Incoming jump from 0x17BB, if !(0x00 < storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x17BB, if !(stack[-1] < storage[keccak256(memory[0x00:0x40])]) 1838 5B JUMPDEST 1839 50 POP // Stack delta = -1 // Block continues label_183A: // Incoming jump from 0x1839 // Incoming jump from 0x176B, if !(storage[keccak256(memory[0x00:0x40])] > 0x00) // Inputs[4] // { // @183B stack[-1] // @183C stack[-2] // @183F stack[-4] // @1840 stack[-3] // } 183A 5B JUMPDEST 183B 80 DUP1 183C 91 SWAP2 183D 50 POP 183E 50 POP 183F 91 SWAP2 1840 90 SWAP1 1841 50 POP 1842 56 *JUMP // Stack delta = -3 // Outputs[1] { @183F stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1843: // Incoming jump from 0x0834 // Inputs[1] { @1849 msg.sender } 1843 5B JUMPDEST 1844 60 PUSH1 0x00 1846 61 PUSH2 0x184e 1849 33 CALLER 184A 61 PUSH2 0x1647 184D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1844 stack[0] = 0x00 // @1846 stack[1] = 0x184e // @1849 stack[2] = msg.sender // } // Block ends with call to 0x1647, returns to 0x184E label_184E: // Incoming return from call to 0x1647 at 0x184D // Inputs[1] { @184F stack[-1] } 184E 5B JUMPDEST 184F 80 DUP1 1850 61 PUSH2 0x185e 1853 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x185e, if stack[-1] label_1854: // Incoming jump from 0x1853, if not stack[-1] // Inputs[1] { @1858 msg.sender } 1854 50 POP 1855 61 PUSH2 0x185d 1858 33 CALLER 1859 61 PUSH2 0x11a4 185C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1855 stack[-1] = 0x185d // @1858 stack[0] = msg.sender // } // Block ends with call to 0x11a4, returns to 0x185D label_185D: // Incoming return from call to 0x11A4 at 0x185C 185D 5B JUMPDEST // Stack delta = +0 // Block continues label_185E: // Incoming jump from 0x1853, if stack[-1] // Incoming jump from 0x185D // Inputs[1] { @1862 stack[-1] } 185E 5B JUMPDEST 185F 61 PUSH2 0x1867 1862 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1867, if stack[-1] label_1863: // Incoming jump from 0x1862, if not stack[-1] // Inputs[1] { @1866 memory[0x00:0x00] } 1863 60 PUSH1 0x00 1865 80 DUP1 1866 FD *REVERT // Stack delta = +0 // Outputs[1] { @1866 revert(memory[0x00:0x00]); } // Block terminates label_1867: // Incoming jump from 0x1862, if stack[-1] // Inputs[3] // { // @186C stack[-2] // @18A6 memory[0x00:0x40] // @18AA storage[keccak256(memory[0x00:0x40])] // } 1867 5B JUMPDEST 1868 60 PUSH1 0x0b 186A 60 PUSH1 0x00 186C 83 DUP4 186D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1882 16 AND 1883 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1898 16 AND 1899 81 DUP2 189A 52 MSTORE 189B 60 PUSH1 0x20 189D 01 ADD 189E 90 SWAP1 189F 81 DUP2 18A0 52 MSTORE 18A1 60 PUSH1 0x20 18A3 01 ADD 18A4 60 PUSH1 0x00 18A6 20 SHA3 18A7 60 PUSH1 0x00 18A9 90 SWAP1 18AA 54 SLOAD 18AB 90 SWAP1 18AC 61 PUSH2 0x0100 18AF 0A EXP 18B0 90 SWAP1 18B1 04 DIV 18B2 60 PUSH1 0xff 18B4 16 AND 18B5 61 PUSH2 0x18bd 18B8 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @189A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @18A0 memory[0x20:0x40] = 0x0b // } // Block ends with conditional jump to 0x18bd, if 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 label_18B9: // Incoming jump from 0x18B8, if not 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // Inputs[1] { @18BC memory[0x00:0x00] } 18B9 60 PUSH1 0x00 18BB 80 DUP1 18BC FD *REVERT // Stack delta = +0 // Outputs[1] { @18BC revert(memory[0x00:0x00]); } // Block terminates label_18BD: // Incoming jump from 0x18B8, if 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // Inputs[8] // { // @18C4 stack[-2] // @18FE memory[0x00:0x40] // @1906 storage[keccak256(memory[0x00:0x40])] // @1950 memory[0x40:0x60] // @1953 memory[0x40:0x60] // @1958 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @195B stack[-1] // @195D stack[-3] // } 18BD 5B JUMPDEST 18BE 60 PUSH1 0x00 18C0 60 PUSH1 0x0b 18C2 60 PUSH1 0x00 18C4 84 DUP5 18C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18DA 16 AND 18DB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18F0 16 AND 18F1 81 DUP2 18F2 52 MSTORE 18F3 60 PUSH1 0x20 18F5 01 ADD 18F6 90 SWAP1 18F7 81 DUP2 18F8 52 MSTORE 18F9 60 PUSH1 0x20 18FB 01 ADD 18FC 60 PUSH1 0x00 18FE 20 SHA3 18FF 60 PUSH1 0x00 1901 61 PUSH2 0x0100 1904 0A EXP 1905 81 DUP2 1906 54 SLOAD 1907 81 DUP2 1908 60 PUSH1 0xff 190A 02 MUL 190B 19 NOT 190C 16 AND 190D 90 SWAP1 190E 83 DUP4 190F 15 ISZERO 1910 15 ISZERO 1911 02 MUL 1912 17 OR 1913 90 SWAP1 1914 55 SSTORE 1915 50 POP 1916 81 DUP2 1917 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 192C 16 AND 192D 7F PUSH32 0xca5069937e68fd197927055037f59d7c90bf75ac104e6e375539ef480c3ad6ee 194E 60 PUSH1 0x40 1950 51 MLOAD 1951 60 PUSH1 0x40 1953 51 MLOAD 1954 80 DUP1 1955 91 SWAP2 1956 03 SUB 1957 90 SWAP1 1958 A2 LOG2 1959 60 PUSH1 0x01 195B 90 SWAP1 195C 50 POP 195D 91 SWAP2 195E 90 SWAP1 195F 50 POP 1960 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @18F2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @18F8 memory[0x20:0x40] = 0x0b // @1914 storage[keccak256(memory[0x00:0x40])] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1958 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xca5069937e68fd197927055037f59d7c90bf75ac104e6e375539ef480c3ad6ee, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // @195D stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_1961: // Incoming call from 0x0863, returns to 0x0864 // Inputs[1] { @197B msg.sender } 1961 5B JUMPDEST 1962 60 PUSH1 0x00 1964 80 DUP1 1965 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 197A 16 AND 197B 33 CALLER 197C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1991 16 AND 1992 14 EQ 1993 15 ISZERO 1994 61 PUSH2 0x199c 1997 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1962 stack[0] = 0x00 } // Block ends with conditional jump to 0x199c, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1998: // Incoming jump from 0x1997, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @199B memory[0x00:0x00] } 1998 60 PUSH1 0x00 199A 80 DUP1 199B FD *REVERT // Stack delta = +0 // Outputs[1] { @199B revert(memory[0x00:0x00]); } // Block terminates label_199C: // Incoming jump from 0x1997, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @19A2 storage[0x07] // @19D6 msg.sender // } 199C 5B JUMPDEST 199D 60 PUSH1 0x07 199F 60 PUSH1 0x00 19A1 90 SWAP1 19A2 54 SLOAD 19A3 90 SWAP1 19A4 61 PUSH2 0x0100 19A7 0A EXP 19A8 90 SWAP1 19A9 04 DIV 19AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19BF 16 AND 19C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19D5 16 AND 19D6 33 CALLER 19D7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19EC 16 AND 19ED 14 EQ 19EE 61 PUSH2 0x19f6 19F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19f6, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] / 0x0100 ** 0x00 label_19F2: // Incoming jump from 0x19F1, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] / 0x0100 ** 0x00 // Inputs[1] { @19F5 memory[0x00:0x00] } 19F2 60 PUSH1 0x00 19F4 80 DUP1 19F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @19F5 revert(memory[0x00:0x00]); } // Block terminates label_19F6: // Incoming jump from 0x19F1, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] / 0x0100 ** 0x00 // Inputs[10] // { // @19FC storage[0x07] // @1A35 storage[0x06] // @1A8C memory[0x40:0x60] // @1A8F memory[0x40:0x60] // @1A94 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1A9A storage[0x07] // @1AC1 storage[0x06] // @1B03 storage[0x07] // @1B3A stack[-2] // @1B3A stack[-1] // } 19F6 5B JUMPDEST 19F7 60 PUSH1 0x07 19F9 60 PUSH1 0x00 19FB 90 SWAP1 19FC 54 SLOAD 19FD 90 SWAP1 19FE 61 PUSH2 0x0100 1A01 0A EXP 1A02 90 SWAP1 1A03 04 DIV 1A04 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A19 16 AND 1A1A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A2F 16 AND 1A30 60 PUSH1 0x06 1A32 60 PUSH1 0x00 1A34 90 SWAP1 1A35 54 SLOAD 1A36 90 SWAP1 1A37 61 PUSH2 0x0100 1A3A 0A EXP 1A3B 90 SWAP1 1A3C 04 DIV 1A3D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A52 16 AND 1A53 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A68 16 AND 1A69 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1A8A 60 PUSH1 0x40 1A8C 51 MLOAD 1A8D 60 PUSH1 0x40 1A8F 51 MLOAD 1A90 80 DUP1 1A91 91 SWAP2 1A92 03 SUB 1A93 90 SWAP1 1A94 A3 LOG3 1A95 60 PUSH1 0x07 1A97 60 PUSH1 0x00 1A99 90 SWAP1 1A9A 54 SLOAD 1A9B 90 SWAP1 1A9C 61 PUSH2 0x0100 1A9F 0A EXP 1AA0 90 SWAP1 1AA1 04 DIV 1AA2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AB7 16 AND 1AB8 60 PUSH1 0x06 1ABA 60 PUSH1 0x00 1ABC 61 PUSH2 0x0100 1ABF 0A EXP 1AC0 81 DUP2 1AC1 54 SLOAD 1AC2 81 DUP2 1AC3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AD8 02 MUL 1AD9 19 NOT 1ADA 16 AND 1ADB 90 SWAP1 1ADC 83 DUP4 1ADD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AF2 16 AND 1AF3 02 MUL 1AF4 17 OR 1AF5 90 SWAP1 1AF6 55 SSTORE 1AF7 50 POP 1AF8 60 PUSH1 0x00 1AFA 60 PUSH1 0x07 1AFC 60 PUSH1 0x00 1AFE 61 PUSH2 0x0100 1B01 0A EXP 1B02 81 DUP2 1B03 54 SLOAD 1B04 81 DUP2 1B05 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B1A 02 MUL 1B1B 19 NOT 1B1C 16 AND 1B1D 90 SWAP1 1B1E 83 DUP4 1B1F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B34 16 AND 1B35 02 MUL 1B36 17 OR 1B37 90 SWAP1 1B38 55 SSTORE 1B39 50 POP 1B3A 90 SWAP1 1B3B 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1A94 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x06] & 0xffffffffffffffffffffffffffffffffffffffff, storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff]); // @1AF6 storage[0x06] = (0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] / 0x0100 ** 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x06]) // @1B38 storage[0x07] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x07]) // @1B3A stack[-2] = stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1B3C: // Incoming jump from 0x08D6 // Inputs[1] { @1B42 msg.sender } 1B3C 5B JUMPDEST 1B3D 60 PUSH1 0x00 1B3F 61 PUSH2 0x1b47 1B42 33 CALLER 1B43 61 PUSH2 0x1647 1B46 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B3D stack[0] = 0x00 // @1B3F stack[1] = 0x1b47 // @1B42 stack[2] = msg.sender // } // Block ends with call to 0x1647, returns to 0x1B47 label_1B47: // Incoming return from call to 0x1647 at 0x1B46 // Inputs[1] { @1B48 stack[-1] } 1B47 5B JUMPDEST 1B48 80 DUP1 1B49 61 PUSH2 0x1b57 1B4C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b57, if stack[-1] label_1B4D: // Incoming jump from 0x1B4C, if not stack[-1] // Inputs[1] { @1B51 msg.sender } 1B4D 50 POP 1B4E 61 PUSH2 0x1b56 1B51 33 CALLER 1B52 61 PUSH2 0x11a4 1B55 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1B4E stack[-1] = 0x1b56 // @1B51 stack[0] = msg.sender // } // Block ends with call to 0x11a4, returns to 0x1B56 label_1B56: // Incoming return from call to 0x11A4 at 0x1B55 1B56 5B JUMPDEST // Stack delta = +0 // Block continues label_1B57: // Incoming jump from 0x1B4C, if stack[-1] // Incoming jump from 0x1B56 // Inputs[1] { @1B5B stack[-1] } 1B57 5B JUMPDEST 1B58 61 PUSH2 0x1b60 1B5B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b60, if stack[-1] label_1B5C: // Incoming jump from 0x1B5B, if not stack[-1] // Inputs[1] { @1B5F memory[0x00:0x00] } 1B5C 60 PUSH1 0x00 1B5E 80 DUP1 1B5F FD *REVERT // Stack delta = +0 // Outputs[1] { @1B5F revert(memory[0x00:0x00]); } // Block terminates label_1B60: // Incoming jump from 0x1B5B, if stack[-1] // Inputs[4] // { // @1B61 stack[-2] // @1B66 stack[-3] // @1BA0 memory[0x00:0x40] // @1BA2 storage[keccak256(memory[0x00:0x40])] // } 1B60 5B JUMPDEST 1B61 81 DUP2 1B62 60 PUSH1 0x0a 1B64 60 PUSH1 0x00 1B66 85 DUP6 1B67 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B7C 16 AND 1B7D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B92 16 AND 1B93 81 DUP2 1B94 52 MSTORE 1B95 60 PUSH1 0x20 1B97 01 ADD 1B98 90 SWAP1 1B99 81 DUP2 1B9A 52 MSTORE 1B9B 60 PUSH1 0x20 1B9D 01 ADD 1B9E 60 PUSH1 0x00 1BA0 20 SHA3 1BA1 80 DUP1 1BA2 54 SLOAD 1BA3 90 SWAP1 1BA4 50 POP 1BA5 11 GT 1BA6 61 PUSH2 0x1c17 1BA9 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1B94 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1B9A memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x1c17, if storage[keccak256(memory[0x00:0x40])] > stack[-2] label_1BAA: // Incoming jump from 0x1BA9, if not storage[keccak256(memory[0x00:0x40])] > stack[-2] // Inputs[3] // { // @1BAC memory[0x40:0x60] // @1C11 memory[0x40:0x60] // @1C16 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1BAA 60 PUSH1 0x40 1BAC 51 MLOAD 1BAD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1BCE 81 DUP2 1BCF 52 MSTORE 1BD0 60 PUSH1 0x04 1BD2 01 ADD 1BD3 80 DUP1 1BD4 80 DUP1 1BD5 60 PUSH1 0x20 1BD7 01 ADD 1BD8 82 DUP3 1BD9 81 DUP2 1BDA 03 SUB 1BDB 82 DUP3 1BDC 52 MSTORE 1BDD 60 PUSH1 0x17 1BDF 81 DUP2 1BE0 52 MSTORE 1BE1 60 PUSH1 0x20 1BE3 01 ADD 1BE4 80 DUP1 1BE5 7F PUSH32 0x5468657265206973206e6f74206c6f636b20696e666f2e000000000000000000 1C06 81 DUP2 1C07 52 MSTORE 1C08 50 POP 1C09 60 PUSH1 0x20 1C0B 01 ADD 1C0C 91 SWAP2 1C0D 50 POP 1C0E 50 POP 1C0F 60 PUSH1 0x40 1C11 51 MLOAD 1C12 80 DUP1 1C13 91 SWAP2 1C14 03 SUB 1C15 90 SWAP1 1C16 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1BCF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1BDC memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1BE0 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x17 // @1C07 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x5468657265206973206e6f74206c6f636b20696e666f2e000000000000000000 // @1C16 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1C17: // Incoming jump from 0x1BA9, if storage[keccak256(memory[0x00:0x40])] > stack[-2] // Inputs[2] // { // @1C1B stack[-3] // @1C1C stack[-2] // } 1C17 5B JUMPDEST 1C18 61 PUSH2 0x1c21 1C1B 83 DUP4 1C1C 83 DUP4 1C1D 61 PUSH2 0x295f 1C20 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C18 stack[0] = 0x1c21 // @1C1B stack[1] = stack[-3] // @1C1C stack[2] = stack[-2] // } // Block ends with call to 0x295f, returns to 0x1C21 label_1C21: // Incoming return from call to 0x295F at 0x1C20 // Inputs[3] // { // @1C25 stack[-2] // @1C27 stack[-5] // @1C28 stack[-4] // } 1C21 5B JUMPDEST 1C22 50 POP 1C23 60 PUSH1 0x01 1C25 90 SWAP1 1C26 50 POP 1C27 92 SWAP3 1C28 91 SWAP2 1C29 50 POP 1C2A 50 POP 1C2B 56 *JUMP // Stack delta = -4 // Outputs[1] { @1C27 stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_1C2C: // Incoming jump from 0x093F // Inputs[1] { @1C30 msg.sender } 1C2C 5B JUMPDEST 1C2D 61 PUSH2 0x1c35 1C30 33 CALLER 1C31 61 PUSH2 0x1647 1C34 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C2D stack[0] = 0x1c35 // @1C30 stack[1] = msg.sender // } // Block ends with call to 0x1647, returns to 0x1C35 label_1C35: // Incoming return from call to 0x1647 at 0x1C34 // Inputs[1] { @1C36 stack[-1] } 1C35 5B JUMPDEST 1C36 80 DUP1 1C37 61 PUSH2 0x1c45 1C3A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c45, if stack[-1] label_1C3B: // Incoming jump from 0x1C3A, if not stack[-1] // Inputs[1] { @1C3F msg.sender } 1C3B 50 POP 1C3C 61 PUSH2 0x1c44 1C3F 33 CALLER 1C40 61 PUSH2 0x11a4 1C43 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1C3C stack[-1] = 0x1c44 // @1C3F stack[0] = msg.sender // } // Block ends with call to 0x11a4, returns to 0x1C44 label_1C44: // Incoming return from call to 0x11A4 at 0x1C43 1C44 5B JUMPDEST // Stack delta = +0 // Block continues label_1C45: // Incoming jump from 0x1C3A, if stack[-1] // Incoming jump from 0x1C44 // Inputs[1] { @1C49 stack[-1] } 1C45 5B JUMPDEST 1C46 61 PUSH2 0x1c4e 1C49 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c4e, if stack[-1] label_1C4A: // Incoming jump from 0x1C49, if not stack[-1] // Inputs[1] { @1C4D memory[0x00:0x00] } 1C4A 60 PUSH1 0x00 1C4C 80 DUP1 1C4D FD *REVERT // Stack delta = +0 // Outputs[1] { @1C4D revert(memory[0x00:0x00]); } // Block terminates label_1C4E: // Incoming jump from 0x1C49, if stack[-1] // Inputs[1] { @1C52 stack[-1] } 1C4E 5B JUMPDEST 1C4F 61 PUSH2 0x1c57 1C52 81 DUP2 1C53 61 PUSH2 0x2c91 1C56 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C4F stack[0] = 0x1c57 // @1C52 stack[1] = stack[-1] // } // Block ends with call to 0x2c91, returns to 0x1C57 label_1C57: // Incoming return from call to 0x2C91 at 0x1C56 // Inputs[1] { @1C59 stack[-2] } 1C57 5B JUMPDEST 1C58 50 POP 1C59 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1C5A: // Incoming jump from 0x099A // Inputs[2] // { // @1C62 storage[0x06] // @1C96 msg.sender // } 1C5A 5B JUMPDEST 1C5B 60 PUSH1 0x00 1C5D 60 PUSH1 0x06 1C5F 60 PUSH1 0x00 1C61 90 SWAP1 1C62 54 SLOAD 1C63 90 SWAP1 1C64 61 PUSH2 0x0100 1C67 0A EXP 1C68 90 SWAP1 1C69 04 DIV 1C6A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C7F 16 AND 1C80 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C95 16 AND 1C96 33 CALLER 1C97 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CAC 16 AND 1CAD 14 EQ 1CAE 61 PUSH2 0x1cb6 1CB1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C5B stack[0] = 0x00 } // Block ends with conditional jump to 0x1cb6, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 label_1CB2: // Incoming jump from 0x1CB1, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 // Inputs[1] { @1CB5 memory[0x00:0x00] } 1CB2 60 PUSH1 0x00 1CB4 80 DUP1 1CB5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CB5 revert(memory[0x00:0x00]); } // Block terminates label_1CB6: // Incoming jump from 0x1CB1, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 // Inputs[2] // { // @1CBA stack[-3] // @1CBB stack[-2] // } 1CB6 5B JUMPDEST 1CB7 61 PUSH2 0x1cc0 1CBA 83 DUP4 1CBB 83 DUP4 1CBC 61 PUSH2 0x2ceb 1CBF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CB7 stack[0] = 0x1cc0 // @1CBA stack[1] = stack[-3] // @1CBB stack[2] = stack[-2] // } // Block ends with call to 0x2ceb, returns to 0x1CC0 label_1CC0: // Incoming return from call to 0x2CEB at 0x1CBF // Inputs[3] // { // @1CC3 stack[-1] // @1CC5 stack[-4] // @1CC6 stack[-3] // } 1CC0 5B JUMPDEST 1CC1 60 PUSH1 0x01 1CC3 90 SWAP1 1CC4 50 POP 1CC5 92 SWAP3 1CC6 91 SWAP2 1CC7 50 POP 1CC8 50 POP 1CC9 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CC5 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_1CCA: // Incoming call from 0x09C9, returns to 0x09CA // Inputs[1] { @1CCE msg.sender } 1CCA 5B JUMPDEST 1CCB 61 PUSH2 0x1cd3 1CCE 33 CALLER 1CCF 61 PUSH2 0x1647 1CD2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1CCB stack[0] = 0x1cd3 // @1CCE stack[1] = msg.sender // } // Block ends with call to 0x1647, returns to 0x1CD3 label_1CD3: // Incoming return from call to 0x1647 at 0x1CD2 // Inputs[1] { @1CD4 stack[-1] } 1CD3 5B JUMPDEST 1CD4 80 DUP1 1CD5 61 PUSH2 0x1ce3 1CD8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ce3, if stack[-1] label_1CD9: // Incoming jump from 0x1CD8, if not stack[-1] // Inputs[1] { @1CDD msg.sender } 1CD9 50 POP 1CDA 61 PUSH2 0x1ce2 1CDD 33 CALLER 1CDE 61 PUSH2 0x11a4 1CE1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1CDA stack[-1] = 0x1ce2 // @1CDD stack[0] = msg.sender // } // Block ends with call to 0x11a4, returns to 0x1CE2 label_1CE2: // Incoming return from call to 0x11A4 at 0x1CE1 1CE2 5B JUMPDEST // Stack delta = +0 // Block continues label_1CE3: // Incoming jump from 0x1CE2 // Incoming jump from 0x1CD8, if stack[-1] // Inputs[1] { @1CE7 stack[-1] } 1CE3 5B JUMPDEST 1CE4 61 PUSH2 0x1cec 1CE7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1cec, if stack[-1] label_1CE8: // Incoming jump from 0x1CE7, if not stack[-1] // Inputs[1] { @1CEB memory[0x00:0x00] } 1CE8 60 PUSH1 0x00 1CEA 80 DUP1 1CEB FD *REVERT // Stack delta = +0 // Outputs[1] { @1CEB revert(memory[0x00:0x00]); } // Block terminates label_1CEC: // Incoming jump from 0x1CE7, if stack[-1] // Inputs[1] { @1CF2 storage[0x09] } 1CEC 5B JUMPDEST 1CED 60 PUSH1 0x09 1CEF 60 PUSH1 0x00 1CF1 90 SWAP1 1CF2 54 SLOAD 1CF3 90 SWAP1 1CF4 61 PUSH2 0x0100 1CF7 0A EXP 1CF8 90 SWAP1 1CF9 04 DIV 1CFA 60 PUSH1 0xff 1CFC 16 AND 1CFD 15 ISZERO 1CFE 61 PUSH2 0x1d06 1D01 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d06, if !(0xff & storage[0x09] / 0x0100 ** 0x00) label_1D02: // Incoming jump from 0x1D01, if not !(0xff & storage[0x09] / 0x0100 ** 0x00) // Inputs[1] { @1D05 memory[0x00:0x00] } 1D02 60 PUSH1 0x00 1D04 80 DUP1 1D05 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D05 revert(memory[0x00:0x00]); } // Block terminates label_1D06: // Incoming jump from 0x1D01, if !(0xff & storage[0x09] / 0x0100 ** 0x00) // Inputs[6] // { // @1D12 storage[0x09] // @1D43 msg.sender // @1D46 memory[0x40:0x60] // @1D7F memory[0x40:0x60] // @1D84 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1D85 stack[-1] // } 1D06 5B JUMPDEST 1D07 60 PUSH1 0x01 1D09 60 PUSH1 0x09 1D0B 60 PUSH1 0x00 1D0D 61 PUSH2 0x0100 1D10 0A EXP 1D11 81 DUP2 1D12 54 SLOAD 1D13 81 DUP2 1D14 60 PUSH1 0xff 1D16 02 MUL 1D17 19 NOT 1D18 16 AND 1D19 90 SWAP1 1D1A 83 DUP4 1D1B 15 ISZERO 1D1C 15 ISZERO 1D1D 02 MUL 1D1E 17 OR 1D1F 90 SWAP1 1D20 55 SSTORE 1D21 50 POP 1D22 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 1D43 33 CALLER 1D44 60 PUSH1 0x40 1D46 51 MLOAD 1D47 80 DUP1 1D48 82 DUP3 1D49 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D5E 16 AND 1D5F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D74 16 AND 1D75 81 DUP2 1D76 52 MSTORE 1D77 60 PUSH1 0x20 1D79 01 ADD 1D7A 91 SWAP2 1D7B 50 POP 1D7C 50 POP 1D7D 60 PUSH1 0x40 1D7F 51 MLOAD 1D80 80 DUP1 1D81 91 SWAP2 1D82 03 SUB 1D83 90 SWAP1 1D84 A1 LOG1 1D85 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1D20 storage[0x09] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x09]) // @1D76 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1D84 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258]); // } // Block ends with unconditional jump to stack[-1] label_1D86: // Incoming call from 0x09E0, returns to 0x09E1 // Inputs[2] // { // @1D8C storage[0x06] // @1DAA stack[-1] // } 1D86 5B JUMPDEST 1D87 60 PUSH1 0x06 1D89 60 PUSH1 0x00 1D8B 90 SWAP1 1D8C 54 SLOAD 1D8D 90 SWAP1 1D8E 61 PUSH2 0x0100 1D91 0A EXP 1D92 90 SWAP1 1D93 04 DIV 1D94 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DA9 16 AND 1DAA 81 DUP2 1DAB 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DA9 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_1DAC: // Incoming call from 0x0A37, returns to 0x0A38 // Inputs[3] // { // @1DB2 storage[0x01] // @1DD3 memory[0x40:0x60] // @1DE6 storage[0x01] // } 1DAC 5B JUMPDEST 1DAD 60 PUSH1 0x60 1DAF 60 PUSH1 0x01 1DB1 80 DUP1 1DB2 54 SLOAD 1DB3 60 PUSH1 0x01 1DB5 81 DUP2 1DB6 60 PUSH1 0x01 1DB8 16 AND 1DB9 15 ISZERO 1DBA 61 PUSH2 0x0100 1DBD 02 MUL 1DBE 03 SUB 1DBF 16 AND 1DC0 60 PUSH1 0x02 1DC2 90 SWAP1 1DC3 04 DIV 1DC4 80 DUP1 1DC5 60 PUSH1 0x1f 1DC7 01 ADD 1DC8 60 PUSH1 0x20 1DCA 80 DUP1 1DCB 91 SWAP2 1DCC 04 DIV 1DCD 02 MUL 1DCE 60 PUSH1 0x20 1DD0 01 ADD 1DD1 60 PUSH1 0x40 1DD3 51 MLOAD 1DD4 90 SWAP1 1DD5 81 DUP2 1DD6 01 ADD 1DD7 60 PUSH1 0x40 1DD9 52 MSTORE 1DDA 80 DUP1 1DDB 92 SWAP3 1DDC 91 SWAP2 1DDD 90 SWAP1 1DDE 81 DUP2 1DDF 81 DUP2 1DE0 52 MSTORE 1DE1 60 PUSH1 0x20 1DE3 01 ADD 1DE4 82 DUP3 1DE5 80 DUP1 1DE6 54 SLOAD 1DE7 60 PUSH1 0x01 1DE9 81 DUP2 1DEA 60 PUSH1 0x01 1DEC 16 AND 1DED 15 ISZERO 1DEE 61 PUSH2 0x0100 1DF1 02 MUL 1DF2 03 SUB 1DF3 16 AND 1DF4 60 PUSH1 0x02 1DF6 90 SWAP1 1DF7 04 DIV 1DF8 80 DUP1 1DF9 15 ISZERO 1DFA 61 PUSH2 0x1e44 1DFD 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1DAD stack[0] = 0x60 // @1DD9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) / 0x20 * 0x20 // @1DDB stack[1] = memory[0x40:0x60] // @1DDC stack[2] = 0x01 // @1DDD stack[3] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @1DE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @1DE3 stack[4] = 0x20 + memory[0x40:0x60] // @1DE4 stack[5] = 0x01 // @1DF7 stack[6] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // } // Block ends with conditional jump to 0x1e44, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) label_1DFE: // Incoming jump from 0x1DFD, if not !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Inputs[1] { @1DFE stack[-1] } 1DFE 80 DUP1 1DFF 60 PUSH1 0x1f 1E01 10 LT 1E02 61 PUSH2 0x1e19 1E05 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e19, if 0x1f < stack[-1] label_1E06: // Incoming jump from 0x1E05, if not 0x1f < stack[-1] // Inputs[4] // { // @1E0A stack[-2] // @1E0B storage[stack[-2]] // @1E0E stack[-3] // @1E10 stack[-1] // } 1E06 61 PUSH2 0x0100 1E09 80 DUP1 1E0A 83 DUP4 1E0B 54 SLOAD 1E0C 04 DIV 1E0D 02 MUL 1E0E 83 DUP4 1E0F 52 MSTORE 1E10 91 SWAP2 1E11 60 PUSH1 0x20 1E13 01 ADD 1E14 91 SWAP2 1E15 61 PUSH2 0x1e44 1E18 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1E0F memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1E14 stack[-1] = stack[-1] // @1E14 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1e44 label_1E19: // Incoming jump from 0x1E05, if 0x1f < stack[-1] // Inputs[5] // { // @1E1A stack[-3] // @1E1B stack[-1] // @1E1D stack[-2] // @1E25 memory[0x00:0x20] // @1E29 storage[keccak256(memory[0x00:0x20])] // } 1E19 5B JUMPDEST 1E1A 82 DUP3 1E1B 01 ADD 1E1C 91 SWAP2 1E1D 90 SWAP1 1E1E 60 PUSH1 0x00 1E20 52 MSTORE 1E21 60 PUSH1 0x20 1E23 60 PUSH1 0x00 1E25 20 SHA3 1E26 90 SWAP1 1E27 5B JUMPDEST 1E28 81 DUP2 1E29 54 SLOAD 1E2A 81 DUP2 1E2B 52 MSTORE 1E2C 90 SWAP1 1E2D 60 PUSH1 0x01 1E2F 01 ADD 1E30 90 SWAP1 1E31 60 PUSH1 0x20 1E33 01 ADD 1E34 80 DUP1 1E35 83 DUP4 1E36 11 GT 1E37 61 PUSH2 0x1e27 1E3A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1E1C stack[-3] = stack[-3] + stack[-1] // @1E20 memory[0x00:0x20] = stack[-2] // @1E2B memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1E30 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1E33 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1e27, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1E3B: // Incoming jump from 0x1E3A, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1E3A, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1E3B stack[-3] // @1E3C stack[-1] // } 1E3B 82 DUP3 1E3C 90 SWAP1 1E3D 03 SUB 1E3E 60 PUSH1 0x1f 1E40 16 AND 1E41 82 DUP3 1E42 01 ADD 1E43 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1E43 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1E43 stack[-1] = stack[-3] // } // Block continues label_1E44: // Incoming jump from 0x1E43 // Incoming jump from 0x1DFD, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Incoming jump from 0x1E18 // Inputs[3] // { // @1E4A stack[-7] // @1E4A stack[-6] // @1E4C stack[-8] // } 1E44 5B JUMPDEST 1E45 50 POP 1E46 50 POP 1E47 50 POP 1E48 50 POP 1E49 50 POP 1E4A 90 SWAP1 1E4B 50 POP 1E4C 90 SWAP1 1E4D 56 *JUMP // Stack delta = -7 // Outputs[1] { @1E4C stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_1E4E: // Incoming jump from 0x0B0B // Inputs[1] { @1E68 stack[-2] } 1E4E 5B JUMPDEST 1E4F 60 PUSH1 0x00 1E51 80 DUP1 1E52 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E67 16 AND 1E68 83 DUP4 1E69 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E7E 16 AND 1E7F 14 EQ 1E80 15 ISZERO 1E81 61 PUSH2 0x1e89 1E84 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E4F stack[0] = 0x00 } // Block ends with conditional jump to 0x1e89, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1E85: // Incoming jump from 0x1E84, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1E88 memory[0x00:0x00] } 1E85 60 PUSH1 0x00 1E87 80 DUP1 1E88 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E88 revert(memory[0x00:0x00]); } // Block terminates label_1E89: // Incoming jump from 0x1E84, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @1E8D stack[-2] // @1E92 msg.sender // @1ECC memory[0x00:0x40] // @1ECF stack[-3] // @1F09 memory[0x00:0x40] // @1F0A storage[keccak256(memory[0x00:0x40])] // } 1E89 5B JUMPDEST 1E8A 61 PUSH2 0x1f18 1E8D 82 DUP3 1E8E 60 PUSH1 0x04 1E90 60 PUSH1 0x00 1E92 33 CALLER 1E93 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EA8 16 AND 1EA9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EBE 16 AND 1EBF 81 DUP2 1EC0 52 MSTORE 1EC1 60 PUSH1 0x20 1EC3 01 ADD 1EC4 90 SWAP1 1EC5 81 DUP2 1EC6 52 MSTORE 1EC7 60 PUSH1 0x20 1EC9 01 ADD 1ECA 60 PUSH1 0x00 1ECC 20 SHA3 1ECD 60 PUSH1 0x00 1ECF 86 DUP7 1ED0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EE5 16 AND 1EE6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EFB 16 AND 1EFC 81 DUP2 1EFD 52 MSTORE 1EFE 60 PUSH1 0x20 1F00 01 ADD 1F01 90 SWAP1 1F02 81 DUP2 1F03 52 MSTORE 1F04 60 PUSH1 0x20 1F06 01 ADD 1F07 60 PUSH1 0x00 1F09 20 SHA3 1F0A 54 SLOAD 1F0B 61 PUSH2 0x2e3f 1F0E 90 SWAP1 1F0F 91 SWAP2 1F10 90 SWAP1 1F11 63 PUSH4 0xffffffff 1F16 16 AND 1F17 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @1E8A stack[0] = 0x1f18 // @1EC0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1EC6 memory[0x20:0x40] = 0x04 // @1EFD memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1F03 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1F0F stack[1] = storage[keccak256(memory[0x00:0x40])] // @1F10 stack[2] = stack[-2] // } // Block ends with call to 0xffffffff & 0x2e3f, returns to 0x1F18 label_1F18: // Incoming return from call to 0x2E3F at 0x1F17 // Inputs[15] // { // @1F1D msg.sender // @1F57 memory[0x00:0x40] // @1F5A stack[-4] // @1F94 memory[0x00:0x40] // @1F95 stack[-1] // @1FB0 msg.sender // @1FEC msg.sender // @2026 memory[0x00:0x40] // @2063 memory[0x00:0x40] // @2064 storage[keccak256(memory[0x00:0x40])] // @2067 memory[0x40:0x60] // @2074 memory[0x40:0x60] // @2079 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @207C stack[-2] // @207E stack[-5] // } 1F18 5B JUMPDEST 1F19 60 PUSH1 0x04 1F1B 60 PUSH1 0x00 1F1D 33 CALLER 1F1E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F33 16 AND 1F34 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F49 16 AND 1F4A 81 DUP2 1F4B 52 MSTORE 1F4C 60 PUSH1 0x20 1F4E 01 ADD 1F4F 90 SWAP1 1F50 81 DUP2 1F51 52 MSTORE 1F52 60 PUSH1 0x20 1F54 01 ADD 1F55 60 PUSH1 0x00 1F57 20 SHA3 1F58 60 PUSH1 0x00 1F5A 85 DUP6 1F5B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F70 16 AND 1F71 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F86 16 AND 1F87 81 DUP2 1F88 52 MSTORE 1F89 60 PUSH1 0x20 1F8B 01 ADD 1F8C 90 SWAP1 1F8D 81 DUP2 1F8E 52 MSTORE 1F8F 60 PUSH1 0x20 1F91 01 ADD 1F92 60 PUSH1 0x00 1F94 20 SHA3 1F95 81 DUP2 1F96 90 SWAP1 1F97 55 SSTORE 1F98 50 POP 1F99 82 DUP3 1F9A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FAF 16 AND 1FB0 33 CALLER 1FB1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FC6 16 AND 1FC7 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1FE8 60 PUSH1 0x04 1FEA 60 PUSH1 0x00 1FEC 33 CALLER 1FED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2002 16 AND 2003 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2018 16 AND 2019 81 DUP2 201A 52 MSTORE 201B 60 PUSH1 0x20 201D 01 ADD 201E 90 SWAP1 201F 81 DUP2 2020 52 MSTORE 2021 60 PUSH1 0x20 2023 01 ADD 2024 60 PUSH1 0x00 2026 20 SHA3 2027 60 PUSH1 0x00 2029 87 DUP8 202A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 203F 16 AND 2040 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2055 16 AND 2056 81 DUP2 2057 52 MSTORE 2058 60 PUSH1 0x20 205A 01 ADD 205B 90 SWAP1 205C 81 DUP2 205D 52 MSTORE 205E 60 PUSH1 0x20 2060 01 ADD 2061 60 PUSH1 0x00 2063 20 SHA3 2064 54 SLOAD 2065 60 PUSH1 0x40 2067 51 MLOAD 2068 80 DUP1 2069 82 DUP3 206A 81 DUP2 206B 52 MSTORE 206C 60 PUSH1 0x20 206E 01 ADD 206F 91 SWAP2 2070 50 POP 2071 50 POP 2072 60 PUSH1 0x40 2074 51 MLOAD 2075 80 DUP1 2076 91 SWAP2 2077 03 SUB 2078 90 SWAP1 2079 A3 LOG3 207A 60 PUSH1 0x01 207C 90 SWAP1 207D 50 POP 207E 92 SWAP3 207F 91 SWAP2 2080 50 POP 2081 50 POP 2082 56 *JUMP // Stack delta = -4 // Outputs[12] // { // @1F4B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1F51 memory[0x20:0x40] = 0x04 // @1F88 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1F8E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1F97 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @201A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2020 memory[0x20:0x40] = 0x04 // @2057 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @205D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @206B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @2079 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @207E stack[-5] = 0x01 // } // Block ends with unconditional jump to stack[-5] label_2083: // Incoming jump from 0x0B7E // Inputs[3] // { // @2086 msg.sender // @20C5 memory[0x00:0x40] // @20C9 storage[keccak256(memory[0x00:0x40])] // } 2083 5B JUMPDEST 2084 60 PUSH1 0x00 2086 33 CALLER 2087 60 PUSH1 0x0b 2089 60 PUSH1 0x00 208B 82 DUP3 208C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20A1 16 AND 20A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20B7 16 AND 20B8 81 DUP2 20B9 52 MSTORE 20BA 60 PUSH1 0x20 20BC 01 ADD 20BD 90 SWAP1 20BE 81 DUP2 20BF 52 MSTORE 20C0 60 PUSH1 0x20 20C2 01 ADD 20C3 60 PUSH1 0x00 20C5 20 SHA3 20C6 60 PUSH1 0x00 20C8 90 SWAP1 20C9 54 SLOAD 20CA 90 SWAP1 20CB 61 PUSH2 0x0100 20CE 0A EXP 20CF 90 SWAP1 20D0 04 DIV 20D1 60 PUSH1 0xff 20D3 16 AND 20D4 15 ISZERO 20D5 61 PUSH2 0x20dd 20D8 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2084 stack[0] = 0x00 // @2086 stack[1] = msg.sender // @20B9 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @20BF memory[0x20:0x40] = 0x0b // } // Block ends with conditional jump to 0x20dd, if !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) label_20D9: // Incoming jump from 0x20D8, if not !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[1] { @20DC memory[0x00:0x00] } 20D9 60 PUSH1 0x00 20DB 80 DUP1 20DC FD *REVERT // Stack delta = +0 // Outputs[1] { @20DC revert(memory[0x00:0x00]); } // Block terminates label_20DD: // Incoming jump from 0x20D8, if !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[3] // { // @20E4 msg.sender // @211E memory[0x00:0x40] // @2120 storage[keccak256(memory[0x00:0x40])] // } 20DD 5B JUMPDEST 20DE 60 PUSH1 0x00 20E0 60 PUSH1 0x0a 20E2 60 PUSH1 0x00 20E4 33 CALLER 20E5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20FA 16 AND 20FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2110 16 AND 2111 81 DUP2 2112 52 MSTORE 2113 60 PUSH1 0x20 2115 01 ADD 2116 90 SWAP1 2117 81 DUP2 2118 52 MSTORE 2119 60 PUSH1 0x20 211B 01 ADD 211C 60 PUSH1 0x00 211E 20 SHA3 211F 80 DUP1 2120 54 SLOAD 2121 90 SWAP1 2122 50 POP 2123 11 GT 2124 15 ISZERO 2125 61 PUSH2 0x2133 2128 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2112 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2118 memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x2133, if !(storage[keccak256(memory[0x00:0x40])] > 0x00) label_2129: // Incoming jump from 0x2128, if not !(storage[keccak256(memory[0x00:0x40])] > 0x00) // Inputs[1] { @212C msg.sender } 2129 61 PUSH2 0x2131 212C 33 CALLER 212D 61 PUSH2 0x2561 2130 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2129 stack[0] = 0x2131 // @212C stack[1] = msg.sender // } // Block ends with call to 0x2561, returns to 0x2131 label_2131: // Incoming return from call to 0x2561 at 0x2130 2131 5B JUMPDEST 2132 50 POP // Stack delta = -1 // Block continues label_2133: // Incoming jump from 0x2128, if !(storage[keccak256(memory[0x00:0x40])] > 0x00) // Incoming jump from 0x2132 // Inputs[2] // { // @2137 stack[-4] // @2138 stack[-3] // } 2133 5B JUMPDEST 2134 61 PUSH2 0x213d 2137 84 DUP5 2138 84 DUP5 2139 61 PUSH2 0x2e5f 213C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2134 stack[0] = 0x213d // @2137 stack[1] = stack[-4] // @2138 stack[2] = stack[-3] // } // Block ends with call to 0x2e5f, returns to 0x213D label_213D: // Incoming return from call to 0x2E5F at 0x213C // Inputs[4] // { // @213E stack[-1] // @213E stack[-3] // @2141 stack[-6] // @2142 stack[-5] // } 213D 5B JUMPDEST 213E 91 SWAP2 213F 50 POP 2140 50 POP 2141 92 SWAP3 2142 91 SWAP2 2143 50 POP 2144 50 POP 2145 56 *JUMP // Stack delta = -5 // Outputs[1] { @2141 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2146: // Incoming jump from 0x0BE7 // Inputs[4] // { // @214C stack[-1] // @2154 memory[0x00:0x40] // @2159 storage[keccak256(memory[0x00:0x40])] // @2164 stack[-2] // } 2146 5B JUMPDEST 2147 60 PUSH1 0x0b 2149 60 PUSH1 0x20 214B 52 MSTORE 214C 80 DUP1 214D 60 PUSH1 0x00 214F 52 MSTORE 2150 60 PUSH1 0x40 2152 60 PUSH1 0x00 2154 20 SHA3 2155 60 PUSH1 0x00 2157 91 SWAP2 2158 50 POP 2159 54 SLOAD 215A 90 SWAP1 215B 61 PUSH2 0x0100 215E 0A EXP 215F 90 SWAP1 2160 04 DIV 2161 60 PUSH1 0xff 2163 16 AND 2164 81 DUP2 2165 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @214B memory[0x20:0x40] = 0x0b // @214F memory[0x00:0x20] = stack[-1] // @2163 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_2166: // Incoming jump from 0x0C5A // Inputs[4] // { // @216C stack[-2] // @2174 memory[0x00:0x40] // @2175 stack[-1] // @2177 storage[keccak256(memory[0x00:0x40])] // } 2166 5B JUMPDEST 2167 60 PUSH1 0x0a 2169 60 PUSH1 0x20 216B 52 MSTORE 216C 81 DUP2 216D 60 PUSH1 0x00 216F 52 MSTORE 2170 60 PUSH1 0x40 2172 60 PUSH1 0x00 2174 20 SHA3 2175 81 DUP2 2176 81 DUP2 2177 54 SLOAD 2178 81 DUP2 2179 10 LT 217A 61 PUSH2 0x217f 217D 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @216B memory[0x20:0x40] = 0x0a // @216F memory[0x00:0x20] = stack[-2] // @2174 stack[0] = keccak256(memory[0x00:0x40]) // @2175 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x217f, if stack[-1] < storage[keccak256(memory[0x00:0x40])] label_217E: // Incoming jump from 0x217D, if not stack[-1] < storage[keccak256(memory[0x00:0x40])] 217E FE *ASSERT // Stack delta = +0 // Outputs[1] { @217E assert(); } // Block terminates label_217F: // Incoming jump from 0x217D, if stack[-1] < storage[keccak256(memory[0x00:0x40])] // Inputs[8] // { // @2180 stack[-2] // @2180 stack[-1] // @2188 memory[0x00:0x20] // @2190 stack[-3] // @2192 stack[-4] // @2199 storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @219F storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @21A2 stack[-5] // } 217F 5B JUMPDEST 2180 90 SWAP1 2181 60 PUSH1 0x00 2183 52 MSTORE 2184 60 PUSH1 0x20 2186 60 PUSH1 0x00 2188 20 SHA3 2189 90 SWAP1 218A 60 PUSH1 0x02 218C 02 MUL 218D 01 ADD 218E 60 PUSH1 0x00 2190 91 SWAP2 2191 50 POP 2192 91 SWAP2 2193 50 POP 2194 50 POP 2195 80 DUP1 2196 60 PUSH1 0x00 2198 01 ADD 2199 54 SLOAD 219A 90 SWAP1 219B 80 DUP1 219C 60 PUSH1 0x01 219E 01 ADD 219F 54 SLOAD 21A0 90 SWAP1 21A1 50 POP 21A2 82 DUP3 21A3 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @2183 memory[0x00:0x20] = stack[-2] // @219A stack[-4] = storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @21A0 stack[-3] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // } // Block ends with unconditional jump to stack[-5] label_21A4: // Incoming call from 0x0C8C, returns to 0x0C8D // Inputs[2] // { // @21AA storage[0x07] // @21C8 stack[-1] // } 21A4 5B JUMPDEST 21A5 60 PUSH1 0x07 21A7 60 PUSH1 0x00 21A9 90 SWAP1 21AA 54 SLOAD 21AB 90 SWAP1 21AC 61 PUSH2 0x0100 21AF 0A EXP 21B0 90 SWAP1 21B1 04 DIV 21B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21C7 16 AND 21C8 81 DUP2 21C9 56 *JUMP // Stack delta = +1 // Outputs[1] { @21C7 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_21CA: // Incoming jump from 0x0D3D // Inputs[6] // { // @21D1 stack[-2] // @220B memory[0x00:0x40] // @220E stack[-1] // @2248 memory[0x00:0x40] // @2249 storage[keccak256(memory[0x00:0x40])] // @224C stack[-3] // } 21CA 5B JUMPDEST 21CB 60 PUSH1 0x00 21CD 60 PUSH1 0x04 21CF 60 PUSH1 0x00 21D1 84 DUP5 21D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21E7 16 AND 21E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21FD 16 AND 21FE 81 DUP2 21FF 52 MSTORE 2200 60 PUSH1 0x20 2202 01 ADD 2203 90 SWAP1 2204 81 DUP2 2205 52 MSTORE 2206 60 PUSH1 0x20 2208 01 ADD 2209 60 PUSH1 0x00 220B 20 SHA3 220C 60 PUSH1 0x00 220E 83 DUP4 220F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2224 16 AND 2225 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 223A 16 AND 223B 81 DUP2 223C 52 MSTORE 223D 60 PUSH1 0x20 223F 01 ADD 2240 90 SWAP1 2241 81 DUP2 2242 52 MSTORE 2243 60 PUSH1 0x20 2245 01 ADD 2246 60 PUSH1 0x00 2248 20 SHA3 2249 54 SLOAD 224A 90 SWAP1 224B 50 POP 224C 92 SWAP3 224D 91 SWAP2 224E 50 POP 224F 50 POP 2250 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @21FF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2205 memory[0x20:0x40] = 0x04 // @223C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @2242 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @224C stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_2251: // Incoming jump from 0x0DB6 // Inputs[1] { @2257 msg.sender } 2251 5B JUMPDEST 2252 60 PUSH1 0x00 2254 61 PUSH2 0x225c 2257 33 CALLER 2258 61 PUSH2 0x1647 225B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2252 stack[0] = 0x00 // @2254 stack[1] = 0x225c // @2257 stack[2] = msg.sender // } // Block ends with call to 0x1647, returns to 0x225C label_225C: // Incoming return from call to 0x1647 at 0x225B // Inputs[1] { @225D stack[-1] } 225C 5B JUMPDEST 225D 80 DUP1 225E 61 PUSH2 0x226c 2261 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x226c, if stack[-1] label_2262: // Incoming jump from 0x2261, if not stack[-1] // Inputs[1] { @2266 msg.sender } 2262 50 POP 2263 61 PUSH2 0x226b 2266 33 CALLER 2267 61 PUSH2 0x11a4 226A 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2263 stack[-1] = 0x226b // @2266 stack[0] = msg.sender // } // Block ends with call to 0x11a4, returns to 0x226B label_226B: // Incoming return from call to 0x11A4 at 0x226A 226B 5B JUMPDEST // Stack delta = +0 // Block continues label_226C: // Incoming jump from 0x226B // Incoming jump from 0x2261, if stack[-1] // Inputs[1] { @2270 stack[-1] } 226C 5B JUMPDEST 226D 61 PUSH2 0x2275 2270 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2275, if stack[-1] label_2271: // Incoming jump from 0x2270, if not stack[-1] // Inputs[1] { @2274 memory[0x00:0x00] } 2271 60 PUSH1 0x00 2273 80 DUP1 2274 FD *REVERT // Stack delta = +0 // Outputs[1] { @2274 revert(memory[0x00:0x00]); } // Block terminates label_2275: // Incoming jump from 0x2270, if stack[-1] // Inputs[3] // { // @2279 msg.sender // @227A stack[-4] // @227B stack[-3] // } 2275 5B JUMPDEST 2276 61 PUSH2 0x2280 2279 33 CALLER 227A 85 DUP6 227B 85 DUP6 227C 61 PUSH2 0x2e8d 227F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2276 stack[0] = 0x2280 // @2279 stack[1] = msg.sender // @227A stack[2] = stack[-4] // @227B stack[3] = stack[-3] // } // Block ends with call to 0x2e8d, returns to 0x2280 label_2280: // Incoming return from call to 0x2E8D at 0x227F // Inputs[3] // { // @2284 stack[-4] // @2285 stack[-3] // @2286 stack[-2] // } 2280 5B JUMPDEST 2281 61 PUSH2 0x228b 2284 84 DUP5 2285 84 DUP5 2286 84 DUP5 2287 61 PUSH2 0x305b 228A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2281 stack[0] = 0x228b // @2284 stack[1] = stack[-4] // @2285 stack[2] = stack[-3] // @2286 stack[3] = stack[-2] // } // Block ends with call to 0x305b, returns to 0x228B label_228B: // Incoming return from call to 0x305B at 0x228A // Inputs[3] // { // @228F stack[-2] // @2291 stack[-6] // @2292 stack[-5] // } 228B 5B JUMPDEST 228C 50 POP 228D 60 PUSH1 0x01 228F 90 SWAP1 2290 50 POP 2291 93 SWAP4 2292 92 SWAP3 2293 50 POP 2294 50 POP 2295 50 POP 2296 56 *JUMP // Stack delta = -5 // Outputs[1] { @2291 stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_2297: // Incoming jump from 0x0E33 // Inputs[1] { @229D msg.sender } 2297 5B JUMPDEST 2298 60 PUSH1 0x00 229A 61 PUSH2 0x22a2 229D 33 CALLER 229E 61 PUSH2 0x1647 22A1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2298 stack[0] = 0x00 // @229A stack[1] = 0x22a2 // @229D stack[2] = msg.sender // } // Block ends with call to 0x1647, returns to 0x22A2 label_22A2: // Incoming return from call to 0x1647 at 0x22A1 // Inputs[1] { @22A3 stack[-1] } 22A2 5B JUMPDEST 22A3 80 DUP1 22A4 61 PUSH2 0x22b2 22A7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x22b2, if stack[-1] label_22A8: // Incoming jump from 0x22A7, if not stack[-1] // Inputs[1] { @22AC msg.sender } 22A8 50 POP 22A9 61 PUSH2 0x22b1 22AC 33 CALLER 22AD 61 PUSH2 0x11a4 22B0 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @22A9 stack[-1] = 0x22b1 // @22AC stack[0] = msg.sender // } // Block ends with call to 0x11a4, returns to 0x22B1 label_22B1: // Incoming return from call to 0x11A4 at 0x22B0 22B1 5B JUMPDEST // Stack delta = +0 // Block continues label_22B2: // Incoming jump from 0x22A7, if stack[-1] // Incoming jump from 0x22B1 // Inputs[1] { @22B6 stack[-1] } 22B2 5B JUMPDEST 22B3 61 PUSH2 0x22bb 22B6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x22bb, if stack[-1] label_22B7: // Incoming jump from 0x22B6, if not stack[-1] // Inputs[1] { @22BA memory[0x00:0x00] } 22B7 60 PUSH1 0x00 22B9 80 DUP1 22BA FD *REVERT // Stack delta = +0 // Outputs[1] { @22BA revert(memory[0x00:0x00]); } // Block terminates label_22BB: // Incoming jump from 0x22B6, if stack[-1] // Inputs[4] // { // @22BC stack[-3] // @22C1 stack[-4] // @22FB memory[0x00:0x40] // @22FC storage[keccak256(memory[0x00:0x40])] // } 22BB 5B JUMPDEST 22BC 82 DUP3 22BD 60 PUSH1 0x03 22BF 60 PUSH1 0x00 22C1 86 DUP7 22C2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22D7 16 AND 22D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22ED 16 AND 22EE 81 DUP2 22EF 52 MSTORE 22F0 60 PUSH1 0x20 22F2 01 ADD 22F3 90 SWAP1 22F4 81 DUP2 22F5 52 MSTORE 22F6 60 PUSH1 0x20 22F8 01 ADD 22F9 60 PUSH1 0x00 22FB 20 SHA3 22FC 54 SLOAD 22FD 10 LT 22FE 15 ISZERO 22FF 61 PUSH2 0x2353 2302 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @22EF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @22F5 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x2353, if !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) label_2303: // Incoming jump from 0x2302, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[3] // { // @2305 memory[0x40:0x60] // @234D memory[0x40:0x60] // @2352 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2303 60 PUSH1 0x40 2305 51 MLOAD 2306 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2327 81 DUP2 2328 52 MSTORE 2329 60 PUSH1 0x04 232B 01 ADD 232C 80 DUP1 232D 80 DUP1 232E 60 PUSH1 0x20 2330 01 ADD 2331 82 DUP3 2332 81 DUP2 2333 03 SUB 2334 82 DUP3 2335 52 MSTORE 2336 60 PUSH1 0x27 2338 81 DUP2 2339 52 MSTORE 233A 60 PUSH1 0x20 233C 01 ADD 233D 80 DUP1 233E 61 PUSH2 0x35c1 2341 60 PUSH1 0x27 2343 91 SWAP2 2344 39 CODECOPY 2345 60 PUSH1 0x40 2347 01 ADD 2348 91 SWAP2 2349 50 POP 234A 50 POP 234B 60 PUSH1 0x40 234D 51 MLOAD 234E 80 DUP1 234F 91 SWAP2 2350 03 SUB 2351 90 SWAP1 2352 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2328 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2335 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2339 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x27 // @2344 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x27] = code[0x35c1:0x35e8] // @2352 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2353: // Incoming jump from 0x2302, if !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[3] // { // @2357 stack[-4] // @2358 stack[-3] // @2359 stack[-2] // } 2353 5B JUMPDEST 2354 61 PUSH2 0x235e 2357 84 DUP5 2358 84 DUP5 2359 84 DUP5 235A 61 PUSH2 0x305b 235D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2354 stack[0] = 0x235e // @2357 stack[1] = stack[-4] // @2358 stack[2] = stack[-3] // @2359 stack[3] = stack[-2] // } // Block ends with call to 0x305b, returns to 0x235E label_235E: // Incoming return from call to 0x305B at 0x235D // Inputs[3] // { // @2362 stack[-2] // @2364 stack[-6] // @2365 stack[-5] // } 235E 5B JUMPDEST 235F 50 POP 2360 60 PUSH1 0x01 2362 90 SWAP1 2363 50 POP 2364 93 SWAP4 2365 92 SWAP3 2366 50 POP 2367 50 POP 2368 50 POP 2369 56 *JUMP // Stack delta = -5 // Outputs[1] { @2364 stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_236A: // Incoming jump from 0x0E9C // Inputs[1] { @2370 msg.sender } 236A 5B JUMPDEST 236B 60 PUSH1 0x00 236D 61 PUSH2 0x2375 2370 33 CALLER 2371 61 PUSH2 0x1647 2374 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @236B stack[0] = 0x00 // @236D stack[1] = 0x2375 // @2370 stack[2] = msg.sender // } // Block ends with call to 0x1647, returns to 0x2375 label_2375: // Incoming return from call to 0x1647 at 0x2374 // Inputs[1] { @2376 stack[-1] } 2375 5B JUMPDEST 2376 80 DUP1 2377 61 PUSH2 0x2385 237A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2385, if stack[-1] label_237B: // Incoming jump from 0x237A, if not stack[-1] // Inputs[1] { @237F msg.sender } 237B 50 POP 237C 61 PUSH2 0x2384 237F 33 CALLER 2380 61 PUSH2 0x11a4 2383 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @237C stack[-1] = 0x2384 // @237F stack[0] = msg.sender // } // Block ends with call to 0x11a4, returns to 0x2384 label_2384: // Incoming return from call to 0x11A4 at 0x2383 2384 5B JUMPDEST // Stack delta = +0 // Block continues label_2385: // Incoming jump from 0x2384 // Incoming jump from 0x237A, if stack[-1] // Inputs[1] { @2389 stack[-1] } 2385 5B JUMPDEST 2386 61 PUSH2 0x238e 2389 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x238e, if stack[-1] label_238A: // Incoming jump from 0x2389, if not stack[-1] // Inputs[1] { @238D memory[0x00:0x00] } 238A 60 PUSH1 0x00 238C 80 DUP1 238D FD *REVERT // Stack delta = +0 // Outputs[1] { @238D revert(memory[0x00:0x00]); } // Block terminates label_238E: // Incoming jump from 0x2389, if stack[-1] // Inputs[3] // { // @2393 stack[-2] // @23CD memory[0x00:0x40] // @23D1 storage[keccak256(memory[0x00:0x40])] // } 238E 5B JUMPDEST 238F 60 PUSH1 0x0b 2391 60 PUSH1 0x00 2393 83 DUP4 2394 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23A9 16 AND 23AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23BF 16 AND 23C0 81 DUP2 23C1 52 MSTORE 23C2 60 PUSH1 0x20 23C4 01 ADD 23C5 90 SWAP1 23C6 81 DUP2 23C7 52 MSTORE 23C8 60 PUSH1 0x20 23CA 01 ADD 23CB 60 PUSH1 0x00 23CD 20 SHA3 23CE 60 PUSH1 0x00 23D0 90 SWAP1 23D1 54 SLOAD 23D2 90 SWAP1 23D3 61 PUSH2 0x0100 23D6 0A EXP 23D7 90 SWAP1 23D8 04 DIV 23D9 60 PUSH1 0xff 23DB 16 AND 23DC 15 ISZERO 23DD 61 PUSH2 0x23e5 23E0 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @23C1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @23C7 memory[0x20:0x40] = 0x0b // } // Block ends with conditional jump to 0x23e5, if !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) label_23E1: // Incoming jump from 0x23E0, if not !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[1] { @23E4 memory[0x00:0x00] } 23E1 60 PUSH1 0x00 23E3 80 DUP1 23E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @23E4 revert(memory[0x00:0x00]); } // Block terminates label_23E5: // Incoming jump from 0x23E0, if !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[8] // { // @23EC stack[-2] // @2426 memory[0x00:0x40] // @242E storage[keccak256(memory[0x00:0x40])] // @2478 memory[0x40:0x60] // @247B memory[0x40:0x60] // @2480 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @2483 stack[-1] // @2485 stack[-3] // } 23E5 5B JUMPDEST 23E6 60 PUSH1 0x01 23E8 60 PUSH1 0x0b 23EA 60 PUSH1 0x00 23EC 84 DUP5 23ED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2402 16 AND 2403 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2418 16 AND 2419 81 DUP2 241A 52 MSTORE 241B 60 PUSH1 0x20 241D 01 ADD 241E 90 SWAP1 241F 81 DUP2 2420 52 MSTORE 2421 60 PUSH1 0x20 2423 01 ADD 2424 60 PUSH1 0x00 2426 20 SHA3 2427 60 PUSH1 0x00 2429 61 PUSH2 0x0100 242C 0A EXP 242D 81 DUP2 242E 54 SLOAD 242F 81 DUP2 2430 60 PUSH1 0xff 2432 02 MUL 2433 19 NOT 2434 16 AND 2435 90 SWAP1 2436 83 DUP4 2437 15 ISZERO 2438 15 ISZERO 2439 02 MUL 243A 17 OR 243B 90 SWAP1 243C 55 SSTORE 243D 50 POP 243E 81 DUP2 243F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2454 16 AND 2455 7F PUSH32 0xaf85b60d26151edd11443b704d424da6c43d0468f2235ebae3d1904dbc323049 2476 60 PUSH1 0x40 2478 51 MLOAD 2479 60 PUSH1 0x40 247B 51 MLOAD 247C 80 DUP1 247D 91 SWAP2 247E 03 SUB 247F 90 SWAP1 2480 A2 LOG2 2481 60 PUSH1 0x01 2483 90 SWAP1 2484 50 POP 2485 91 SWAP2 2486 90 SWAP1 2487 50 POP 2488 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @241A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2420 memory[0x20:0x40] = 0x0b // @243C storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @2480 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xaf85b60d26151edd11443b704d424da6c43d0468f2235ebae3d1904dbc323049, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // @2485 stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_2489: // Incoming jump from 0x0F05 // Inputs[2] // { // @248F storage[0x06] // @24C3 msg.sender // } 2489 5B JUMPDEST 248A 60 PUSH1 0x06 248C 60 PUSH1 0x00 248E 90 SWAP1 248F 54 SLOAD 2490 90 SWAP1 2491 61 PUSH2 0x0100 2494 0A EXP 2495 90 SWAP1 2496 04 DIV 2497 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24AC 16 AND 24AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24C2 16 AND 24C3 33 CALLER 24C4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24D9 16 AND 24DA 14 EQ 24DB 61 PUSH2 0x24e3 24DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x24e3, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 label_24DF: // Incoming jump from 0x24DE, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 // Inputs[1] { @24E2 memory[0x00:0x00] } 24DF 60 PUSH1 0x00 24E1 80 DUP1 24E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @24E2 revert(memory[0x00:0x00]); } // Block terminates label_24E3: // Incoming jump from 0x24DE, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] / 0x0100 ** 0x00 // Inputs[1] { @24FC stack[-1] } 24E3 5B JUMPDEST 24E4 60 PUSH1 0x00 24E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24FB 16 AND 24FC 81 DUP2 24FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2512 16 AND 2513 14 EQ 2514 15 ISZERO 2515 61 PUSH2 0x251d 2518 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x251d, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2519: // Incoming jump from 0x2518, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @251C memory[0x00:0x00] } 2519 60 PUSH1 0x00 251B 80 DUP1 251C FD *REVERT // Stack delta = +0 // Outputs[1] { @251C revert(memory[0x00:0x00]); } // Block terminates label_251D: // Incoming jump from 0x2518, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @251E stack[-1] // @2528 storage[0x07] // @2560 stack[-2] // } 251D 5B JUMPDEST 251E 80 DUP1 251F 60 PUSH1 0x07 2521 60 PUSH1 0x00 2523 61 PUSH2 0x0100 2526 0A EXP 2527 81 DUP2 2528 54 SLOAD 2529 81 DUP2 252A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 253F 02 MUL 2540 19 NOT 2541 16 AND 2542 90 SWAP1 2543 83 DUP4 2544 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2559 16 AND 255A 02 MUL 255B 17 OR 255C 90 SWAP1 255D 55 SSTORE 255E 50 POP 255F 50 POP 2560 56 *JUMP // Stack delta = -2 // Outputs[1] { @255D storage[0x07] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x07]) } // Block ends with unconditional jump to stack[-2] label_2561: // Incoming call from 0x118C, returns to 0x118D // Incoming call from 0x2130, returns to 0x2131 // Inputs[3] // { // @256E stack[-1] // @25A8 memory[0x00:0x40] // @25AA storage[keccak256(memory[0x00:0x40])] // } 2561 5B JUMPDEST 2562 60 PUSH1 0x00 2564 80 DUP1 2565 60 PUSH1 0x00 2567 90 SWAP1 2568 50 POP 2569 5B JUMPDEST 256A 60 PUSH1 0x0a 256C 60 PUSH1 0x00 256E 84 DUP5 256F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2584 16 AND 2585 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 259A 16 AND 259B 81 DUP2 259C 52 MSTORE 259D 60 PUSH1 0x20 259F 01 ADD 25A0 90 SWAP1 25A1 81 DUP2 25A2 52 MSTORE 25A3 60 PUSH1 0x20 25A5 01 ADD 25A6 60 PUSH1 0x00 25A8 20 SHA3 25A9 80 DUP1 25AA 54 SLOAD 25AB 90 SWAP1 25AC 50 POP 25AD 81 DUP2 25AE 10 LT 25AF 15 ISZERO 25B0 61 PUSH2 0x2639 25B3 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2562 stack[0] = 0x00 // @2567 stack[1] = 0x00 // @259C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @25A2 memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x2639, if !(0x00 < storage[keccak256(memory[0x00:0x40])]) label_25B4: // Incoming jump from 0x25B3, if not !(0x00 < storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x25B3, if not !(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Inputs[5] // { // @25B4 block.timestamp // @25B9 stack[-3] // @25F3 memory[0x00:0x40] // @25F4 stack[-1] // @25F6 storage[keccak256(memory[0x00:0x40])] // } 25B4 42 TIMESTAMP 25B5 60 PUSH1 0x0a 25B7 60 PUSH1 0x00 25B9 85 DUP6 25BA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25CF 16 AND 25D0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25E5 16 AND 25E6 81 DUP2 25E7 52 MSTORE 25E8 60 PUSH1 0x20 25EA 01 ADD 25EB 90 SWAP1 25EC 81 DUP2 25ED 52 MSTORE 25EE 60 PUSH1 0x20 25F0 01 ADD 25F1 60 PUSH1 0x00 25F3 20 SHA3 25F4 82 DUP3 25F5 81 DUP2 25F6 54 SLOAD 25F7 81 DUP2 25F8 10 LT 25F9 61 PUSH2 0x25fe 25FC 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @25B4 stack[0] = block.timestamp // @25E7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @25ED memory[0x20:0x40] = 0x0a // @25F3 stack[1] = keccak256(memory[0x00:0x40]) // @25F4 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x25fe, if stack[-1] < storage[keccak256(memory[0x00:0x40])] label_25FD: // Incoming jump from 0x25FC, if not stack[-1] < storage[keccak256(memory[0x00:0x40])] 25FD FE *ASSERT // Stack delta = +0 // Outputs[1] { @25FD assert(); } // Block terminates label_25FE: // Incoming jump from 0x25FC, if stack[-1] < storage[keccak256(memory[0x00:0x40])] // Inputs[5] // { // @25FF stack[-2] // @25FF stack[-1] // @2607 memory[0x00:0x20] // @2610 storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @2611 stack[-3] // } 25FE 5B JUMPDEST 25FF 90 SWAP1 2600 60 PUSH1 0x00 2602 52 MSTORE 2603 60 PUSH1 0x20 2605 60 PUSH1 0x00 2607 20 SHA3 2608 90 SWAP1 2609 60 PUSH1 0x02 260B 02 MUL 260C 01 ADD 260D 60 PUSH1 0x00 260F 01 ADD 2610 54 SLOAD 2611 11 GT 2612 61 PUSH2 0x262c 2615 57 *JUMPI // Stack delta = -3 // Outputs[1] { @2602 memory[0x00:0x20] = stack[-2] } // Block ends with conditional jump to 0x262c, if storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] > stack[-3] label_2616: // Incoming jump from 0x2615, if not storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] > stack[-3] // Inputs[2] // { // @2619 stack[-3] // @261A stack[-1] // } 2616 61 PUSH2 0x261f 2619 83 DUP4 261A 82 DUP3 261B 61 PUSH2 0x295f 261E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2616 stack[0] = 0x261f // @2619 stack[1] = stack[-3] // @261A stack[2] = stack[-1] // } // Block ends with call to 0x295f, returns to 0x261F label_261F: // Incoming return from call to 0x295F at 0x261E // Inputs[1] { @2620 stack[-1] } 261F 5B JUMPDEST 2620 15 ISZERO 2621 61 PUSH2 0x262b 2624 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x262b, if !stack[-1] label_2625: // Incoming jump from 0x2624, if not !stack[-1] // Inputs[1] { @2627 stack[-1] } 2625 60 PUSH1 0x01 2627 81 DUP2 2628 03 SUB 2629 90 SWAP1 262A 50 POP 262B 5B JUMPDEST // Stack delta = +0 // Outputs[1] { @2629 stack[-1] = stack[-1] - 0x01 } // Block continues label_262C: // Incoming jump from 0x262B // Incoming jump from 0x262B // Incoming jump from 0x2615, if storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] > stack[-3] // Inputs[1] { @262D stack[-1] } 262C 5B JUMPDEST 262D 80 DUP1 262E 80 DUP1 262F 60 PUSH1 0x01 2631 01 ADD 2632 91 SWAP2 2633 50 POP 2634 50 POP 2635 61 PUSH2 0x2569 2638 56 *JUMP // Stack delta = +0 // Outputs[1] { @2632 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x2569 label_2639: // Incoming jump from 0x25B3, if !(0x00 < storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x25B3, if !(stack[-1] < storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @263D stack[-2] // @263F stack[-4] // @2640 stack[-3] // } 2639 5B JUMPDEST 263A 50 POP 263B 60 PUSH1 0x01 263D 90 SWAP1 263E 50 POP 263F 91 SWAP2 2640 90 SWAP1 2641 50 POP 2642 56 *JUMP // Stack delta = -3 // Outputs[1] { @263F stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_2643: // Incoming call from 0x1199, returns to 0x119A // Inputs[1] { @264B storage[0x09] } 2643 5B JUMPDEST 2644 60 PUSH1 0x00 2646 60 PUSH1 0x09 2648 60 PUSH1 0x00 264A 90 SWAP1 264B 54 SLOAD 264C 90 SWAP1 264D 61 PUSH2 0x0100 2650 0A EXP 2651 90 SWAP1 2652 04 DIV 2653 60 PUSH1 0xff 2655 16 AND 2656 15 ISZERO 2657 61 PUSH2 0x265f 265A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2644 stack[0] = 0x00 } // Block ends with conditional jump to 0x265f, if !(0xff & storage[0x09] / 0x0100 ** 0x00) label_265B: // Incoming jump from 0x265A, if not !(0xff & storage[0x09] / 0x0100 ** 0x00) // Inputs[1] { @265E memory[0x00:0x00] } 265B 60 PUSH1 0x00 265D 80 DUP1 265E FD *REVERT // Stack delta = +0 // Outputs[1] { @265E revert(memory[0x00:0x00]); } // Block terminates label_265F: // Incoming jump from 0x265A, if !(0xff & storage[0x09] / 0x0100 ** 0x00) // Inputs[3] // { // @2663 stack[-4] // @2664 stack[-3] // @2665 stack[-2] // } 265F 5B JUMPDEST 2660 61 PUSH2 0x266a 2663 84 DUP5 2664 84 DUP5 2665 84 DUP5 2666 61 PUSH2 0x31e9 2669 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2660 stack[0] = 0x266a // @2663 stack[1] = stack[-4] // @2664 stack[2] = stack[-3] // @2665 stack[3] = stack[-2] // } // Block ends with call to 0x31e9, returns to 0x266A label_266A: // Incoming return from call to 0x31E9 at 0x2669 // Inputs[4] // { // @266B stack[-1] // @266B stack[-2] // @266D stack[-6] // @266E stack[-5] // } 266A 5B JUMPDEST 266B 90 SWAP1 266C 50 POP 266D 93 SWAP4 266E 92 SWAP3 266F 50 POP 2670 50 POP 2671 50 POP 2672 56 *JUMP // Stack delta = -5 // Outputs[1] { @266D stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2673: // Incoming call from 0x12E3, returns to 0x12E4 // Inputs[3] // { // @2674 stack[-1] // @267E storage[0x09] // @26B6 stack[-2] // } 2673 5B JUMPDEST 2674 80 DUP1 2675 60 PUSH1 0x09 2677 60 PUSH1 0x01 2679 61 PUSH2 0x0100 267C 0A EXP 267D 81 DUP2 267E 54 SLOAD 267F 81 DUP2 2680 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2695 02 MUL 2696 19 NOT 2697 16 AND 2698 90 SWAP1 2699 83 DUP4 269A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26AF 16 AND 26B0 02 MUL 26B1 17 OR 26B2 90 SWAP1 26B3 55 SSTORE 26B4 50 POP 26B5 50 POP 26B6 56 *JUMP // Stack delta = -2 // Outputs[1] { @26B3 storage[0x09] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x01 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x01) & storage[0x09]) } // Block ends with unconditional jump to stack[-2] label_26B7: // Incoming call from 0x2724, returns to 0x2725 // Incoming call from 0x277C, returns to 0x277D // Incoming call from 0x13B0, returns to 0x13B1 // Incoming call from 0x2FAD, returns to 0x2FAE // Incoming jump from 0x1828 // Incoming call from 0x2C41, returns to 0x2C42 // Inputs[2] // { // @26BB stack[-1] // @26BC stack[-2] // } 26B7 5B JUMPDEST 26B8 60 PUSH1 0x00 26BA 80 DUP1 26BB 82 DUP3 26BC 84 DUP5 26BD 01 ADD 26BE 90 SWAP1 26BF 50 POP 26C0 83 DUP4 26C1 81 DUP2 26C2 10 LT 26C3 15 ISZERO 26C4 61 PUSH2 0x26cc 26C7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @26B8 stack[0] = 0x00 // @26BE stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x26cc, if !(stack[-2] + stack[-1] < stack[-2]) label_26C8: // Incoming jump from 0x26C7, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[1] { @26CB memory[0x00:0x00] } 26C8 60 PUSH1 0x00 26CA 80 DUP1 26CB FD *REVERT // Stack delta = +0 // Outputs[1] { @26CB revert(memory[0x00:0x00]); } // Block terminates label_26CC: // Incoming jump from 0x26C7, if !(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @26CD stack[-1] // @26CE stack[-2] // @26D1 stack[-5] // @26D2 stack[-4] // } 26CC 5B JUMPDEST 26CD 80 DUP1 26CE 91 SWAP2 26CF 50 POP 26D0 50 POP 26D1 92 SWAP3 26D2 91 SWAP2 26D3 50 POP 26D4 50 POP 26D5 56 *JUMP // Stack delta = -4 // Outputs[1] { @26D1 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_26D6: // Incoming call from 0x163C, returns to 0x163D // Inputs[1] { @26EF stack[-2] } 26D6 5B JUMPDEST 26D7 60 PUSH1 0x00 26D9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26EE 16 AND 26EF 82 DUP3 26F0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2705 16 AND 2706 14 EQ 2707 15 ISZERO 2708 61 PUSH2 0x2710 270B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2710, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_270C: // Incoming jump from 0x270B, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @270F memory[0x00:0x00] } 270C 60 PUSH1 0x00 270E 80 DUP1 270F FD *REVERT // Stack delta = +0 // Outputs[1] { @270F revert(memory[0x00:0x00]); } // Block terminates label_2710: // Incoming jump from 0x270B, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @2714 stack[-1] // @2717 storage[0x05] // } 2710 5B JUMPDEST 2711 61 PUSH2 0x2725 2714 81 DUP2 2715 60 PUSH1 0x05 2717 54 SLOAD 2718 61 PUSH2 0x26b7 271B 90 SWAP1 271C 91 SWAP2 271D 90 SWAP1 271E 63 PUSH4 0xffffffff 2723 16 AND 2724 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2711 stack[0] = 0x2725 // @271C stack[1] = storage[0x05] // @271D stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x26b7, returns to 0x2725 label_2725: // Incoming return from call to 0x26B7 at 0x2724 // Inputs[5] // { // @2728 stack[-1] // @272F stack[-2] // @2734 stack[-3] // @276E memory[0x00:0x40] // @276F storage[keccak256(memory[0x00:0x40])] // } 2725 5B JUMPDEST 2726 60 PUSH1 0x05 2728 81 DUP2 2729 90 SWAP1 272A 55 SSTORE 272B 50 POP 272C 61 PUSH2 0x277d 272F 81 DUP2 2730 60 PUSH1 0x03 2732 60 PUSH1 0x00 2734 85 DUP6 2735 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 274A 16 AND 274B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2760 16 AND 2761 81 DUP2 2762 52 MSTORE 2763 60 PUSH1 0x20 2765 01 ADD 2766 90 SWAP1 2767 81 DUP2 2768 52 MSTORE 2769 60 PUSH1 0x20 276B 01 ADD 276C 60 PUSH1 0x00 276E 20 SHA3 276F 54 SLOAD 2770 61 PUSH2 0x26b7 2773 90 SWAP1 2774 91 SWAP2 2775 90 SWAP1 2776 63 PUSH4 0xffffffff 277B 16 AND 277C 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @272A storage[0x05] = stack[-1] // @272C stack[-1] = 0x277d // @2762 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2768 memory[0x20:0x40] = 0x03 // @2774 stack[0] = storage[keccak256(memory[0x00:0x40])] // @2775 stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x26b7, returns to 0x277D label_277D: // Incoming return from call to 0x26B7 at 0x277C // Inputs[8] // { // @2782 stack[-3] // @27BC memory[0x00:0x40] // @27BD stack[-1] // @2811 stack[-2] // @2814 memory[0x40:0x60] // @2821 memory[0x40:0x60] // @2826 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @2829 stack[-4] // } 277D 5B JUMPDEST 277E 60 PUSH1 0x03 2780 60 PUSH1 0x00 2782 84 DUP5 2783 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2798 16 AND 2799 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27AE 16 AND 27AF 81 DUP2 27B0 52 MSTORE 27B1 60 PUSH1 0x20 27B3 01 ADD 27B4 90 SWAP1 27B5 81 DUP2 27B6 52 MSTORE 27B7 60 PUSH1 0x20 27B9 01 ADD 27BA 60 PUSH1 0x00 27BC 20 SHA3 27BD 81 DUP2 27BE 90 SWAP1 27BF 55 SSTORE 27C0 50 POP 27C1 81 DUP2 27C2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27D7 16 AND 27D8 60 PUSH1 0x00 27DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27EF 16 AND 27F0 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2811 83 DUP4 2812 60 PUSH1 0x40 2814 51 MLOAD 2815 80 DUP1 2816 82 DUP3 2817 81 DUP2 2818 52 MSTORE 2819 60 PUSH1 0x20 281B 01 ADD 281C 91 SWAP2 281D 50 POP 281E 50 POP 281F 60 PUSH1 0x40 2821 51 MLOAD 2822 80 DUP1 2823 91 SWAP2 2824 03 SUB 2825 90 SWAP1 2826 A3 LOG3 2827 50 POP 2828 50 POP 2829 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @27B0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @27B6 memory[0x20:0x40] = 0x03 // @27BF storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2818 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @2826 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] label_282A: // Incoming call from 0x3434, returns to 0x3435 // Incoming call from 0x34DF, returns to 0x34E0 // Incoming call from 0x165C, returns to 0x165D // Inputs[1] { @2844 stack[-1] } 282A 5B JUMPDEST 282B 60 PUSH1 0x00 282D 80 DUP1 282E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2843 16 AND 2844 82 DUP3 2845 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 285A 16 AND 285B 14 EQ 285C 15 ISZERO 285D 61 PUSH2 0x2865 2860 57 *JUMPI // Stack delta = +1 // Outputs[1] { @282B stack[0] = 0x00 } // Block ends with conditional jump to 0x2865, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2861: // Incoming jump from 0x2860, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2864 memory[0x00:0x00] } 2861 60 PUSH1 0x00 2863 80 DUP1 2864 FD *REVERT // Stack delta = +0 // Outputs[1] { @2864 revert(memory[0x00:0x00]); } // Block terminates label_2865: // Incoming jump from 0x2860, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @2866 stack[-3] // @286C stack[-2] // @28A6 memory[0x00:0x40] // @28AA storage[keccak256(memory[0x00:0x40])] // @28B5 stack[-1] // @28B7 stack[-4] // } 2865 5B JUMPDEST 2866 82 DUP3 2867 60 PUSH1 0x00 2869 01 ADD 286A 60 PUSH1 0x00 286C 83 DUP4 286D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2882 16 AND 2883 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2898 16 AND 2899 81 DUP2 289A 52 MSTORE 289B 60 PUSH1 0x20 289D 01 ADD 289E 90 SWAP1 289F 81 DUP2 28A0 52 MSTORE 28A1 60 PUSH1 0x20 28A3 01 ADD 28A4 60 PUSH1 0x00 28A6 20 SHA3 28A7 60 PUSH1 0x00 28A9 90 SWAP1 28AA 54 SLOAD 28AB 90 SWAP1 28AC 61 PUSH2 0x0100 28AF 0A EXP 28B0 90 SWAP1 28B1 04 DIV 28B2 60 PUSH1 0xff 28B4 16 AND 28B5 90 SWAP1 28B6 50 POP 28B7 92 SWAP3 28B8 91 SWAP2 28B9 50 POP 28BA 50 POP 28BB 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @289A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @28A0 memory[0x20:0x40] = 0x00 + stack[-3] // @28B7 stack[-4] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-4] label_28BC: // Incoming call from 0x170F, returns to 0x1710 // Incoming call from 0x1703, returns to 0x1704 // Inputs[1] { @28C0 stack[-1] } 28BC 5B JUMPDEST 28BD 61 PUSH2 0x28d0 28C0 81 DUP2 28C1 60 PUSH1 0x08 28C3 61 PUSH2 0x33f1 28C6 90 SWAP1 28C7 91 SWAP2 28C8 90 SWAP1 28C9 63 PUSH4 0xffffffff 28CE 16 AND 28CF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @28BD stack[0] = 0x28d0 // @28C7 stack[1] = 0x08 // @28C8 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x33f1, returns to 0x28D0 label_28D0: // Incoming return from call to 0x33F1 at 0x28CF // Inputs[5] // { // @28D1 stack[-1] // @290B memory[0x40:0x60] // @290E memory[0x40:0x60] // @2913 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @2915 stack[-2] // } 28D0 5B JUMPDEST 28D1 80 DUP1 28D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28E7 16 AND 28E8 7F PUSH32 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e 2909 60 PUSH1 0x40 290B 51 MLOAD 290C 60 PUSH1 0x40 290E 51 MLOAD 290F 80 DUP1 2910 91 SWAP2 2911 03 SUB 2912 90 SWAP1 2913 A2 LOG2 2914 50 POP 2915 56 *JUMP // Stack delta = -2 // Outputs[1] { @2913 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); } // Block ends with unconditional jump to stack[-2] label_2916: // Incoming call from 0x171D, returns to 0x171E // Inputs[4] // { // @291D stack[-1] // @2957 memory[0x00:0x40] // @2958 storage[keccak256(memory[0x00:0x40])] // @295B stack[-2] // } 2916 5B JUMPDEST 2917 60 PUSH1 0x00 2919 60 PUSH1 0x03 291B 60 PUSH1 0x00 291D 83 DUP4 291E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2933 16 AND 2934 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2949 16 AND 294A 81 DUP2 294B 52 MSTORE 294C 60 PUSH1 0x20 294E 01 ADD 294F 90 SWAP1 2950 81 DUP2 2951 52 MSTORE 2952 60 PUSH1 0x20 2954 01 ADD 2955 60 PUSH1 0x00 2957 20 SHA3 2958 54 SLOAD 2959 90 SWAP1 295A 50 POP 295B 91 SWAP2 295C 90 SWAP1 295D 50 POP 295E 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @294B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @2951 memory[0x20:0x40] = 0x03 // @295B stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_295F: // Incoming call from 0x1C20, returns to 0x1C21 // Incoming call from 0x261E, returns to 0x261F // Inputs[4] // { // @2967 stack[-2] // @29A1 memory[0x00:0x40] // @29A2 stack[-1] // @29A4 storage[keccak256(memory[0x00:0x40])] // } 295F 5B JUMPDEST 2960 60 PUSH1 0x00 2962 80 DUP1 2963 60 PUSH1 0x0a 2965 60 PUSH1 0x00 2967 85 DUP6 2968 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 297D 16 AND 297E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2993 16 AND 2994 81 DUP2 2995 52 MSTORE 2996 60 PUSH1 0x20 2998 01 ADD 2999 90 SWAP1 299A 81 DUP2 299B 52 MSTORE 299C 60 PUSH1 0x20 299E 01 ADD 299F 60 PUSH1 0x00 29A1 20 SHA3 29A2 83 DUP4 29A3 81 DUP2 29A4 54 SLOAD 29A5 81 DUP2 29A6 10 LT 29A7 61 PUSH2 0x29ac 29AA 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @2960 stack[0] = 0x00 // @2962 stack[1] = 0x00 // @2995 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @299B memory[0x20:0x40] = 0x0a // @29A1 stack[2] = keccak256(memory[0x00:0x40]) // @29A2 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x29ac, if stack[-1] < storage[keccak256(memory[0x00:0x40])] label_29AB: // Incoming jump from 0x29AA, if not stack[-1] < storage[keccak256(memory[0x00:0x40])] 29AB FE *ASSERT // Stack delta = +0 // Outputs[1] { @29AB assert(); } // Block terminates label_29AC: // Incoming jump from 0x29AA, if stack[-1] < storage[keccak256(memory[0x00:0x40])] // Inputs[9] // { // @29AD stack[-2] // @29AD stack[-1] // @29B5 memory[0x00:0x20] // @29BB stack[-3] // @29C3 storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @29CA stack[-6] // @2A04 memory[0x00:0x40] // @2A05 stack[-5] // @2A07 storage[keccak256(memory[0x00:0x40])] // } 29AC 5B JUMPDEST 29AD 90 SWAP1 29AE 60 PUSH1 0x00 29B0 52 MSTORE 29B1 60 PUSH1 0x20 29B3 60 PUSH1 0x00 29B5 20 SHA3 29B6 90 SWAP1 29B7 60 PUSH1 0x02 29B9 02 MUL 29BA 01 ADD 29BB 90 SWAP1 29BC 50 POP 29BD 60 PUSH1 0x00 29BF 81 DUP2 29C0 60 PUSH1 0x01 29C2 01 ADD 29C3 54 SLOAD 29C4 90 SWAP1 29C5 50 POP 29C6 60 PUSH1 0x0a 29C8 60 PUSH1 0x00 29CA 86 DUP7 29CB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29E0 16 AND 29E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29F6 16 AND 29F7 81 DUP2 29F8 52 MSTORE 29F9 60 PUSH1 0x20 29FB 01 ADD 29FC 90 SWAP1 29FD 81 DUP2 29FE 52 MSTORE 29FF 60 PUSH1 0x20 2A01 01 ADD 2A02 60 PUSH1 0x00 2A04 20 SHA3 2A05 84 DUP5 2A06 81 DUP2 2A07 54 SLOAD 2A08 81 DUP2 2A09 10 LT 2A0A 61 PUSH2 0x2a0f 2A0D 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @29B0 memory[0x00:0x20] = stack[-2] // @29BB stack[-3] = 0x02 * stack[-1] + keccak256(memory[0x00:0x20]) // @29C4 stack[-2] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @29F8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @29FE memory[0x20:0x40] = 0x0a // @2A04 stack[-1] = keccak256(memory[0x00:0x40]) // @2A05 stack[0] = stack[-5] // } // Block ends with conditional jump to 0x2a0f, if stack[-5] < storage[keccak256(memory[0x00:0x40])] label_2A0E: // Incoming jump from 0x2A0D, if not stack[-5] < storage[keccak256(memory[0x00:0x40])] 2A0E FE *ASSERT // Stack delta = +0 // Outputs[1] { @2A0E assert(); } // Block terminates label_2A0F: // Incoming jump from 0x2A0D, if stack[-5] < storage[keccak256(memory[0x00:0x40])] // Inputs[7] // { // @2A10 stack[-1] // @2A10 stack[-2] // @2A18 memory[0x00:0x20] // @2A35 stack[-7] // @2A6F memory[0x00:0x40] // @2AB3 memory[0x00:0x40] // @2AB5 storage[keccak256(memory[0x00:0x40])] // } 2A0F 5B JUMPDEST 2A10 90 SWAP1 2A11 60 PUSH1 0x00 2A13 52 MSTORE 2A14 60 PUSH1 0x20 2A16 60 PUSH1 0x00 2A18 20 SHA3 2A19 90 SWAP1 2A1A 60 PUSH1 0x02 2A1C 02 MUL 2A1D 01 ADD 2A1E 60 PUSH1 0x00 2A20 80 DUP1 2A21 82 DUP3 2A22 01 ADD 2A23 60 PUSH1 0x00 2A25 90 SWAP1 2A26 55 SSTORE 2A27 60 PUSH1 0x01 2A29 82 DUP3 2A2A 01 ADD 2A2B 60 PUSH1 0x00 2A2D 90 SWAP1 2A2E 55 SSTORE 2A2F 50 POP 2A30 50 POP 2A31 60 PUSH1 0x0a 2A33 60 PUSH1 0x00 2A35 86 DUP7 2A36 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A4B 16 AND 2A4C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A61 16 AND 2A62 81 DUP2 2A63 52 MSTORE 2A64 60 PUSH1 0x20 2A66 01 ADD 2A67 90 SWAP1 2A68 81 DUP2 2A69 52 MSTORE 2A6A 60 PUSH1 0x20 2A6C 01 ADD 2A6D 60 PUSH1 0x00 2A6F 20 SHA3 2A70 61 PUSH2 0x2ac5 2A73 60 PUSH1 0x01 2A75 60 PUSH1 0x0a 2A77 60 PUSH1 0x00 2A79 89 DUP10 2A7A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A8F 16 AND 2A90 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2AA5 16 AND 2AA6 81 DUP2 2AA7 52 MSTORE 2AA8 60 PUSH1 0x20 2AAA 01 ADD 2AAB 90 SWAP1 2AAC 81 DUP2 2AAD 52 MSTORE 2AAE 60 PUSH1 0x20 2AB0 01 ADD 2AB1 60 PUSH1 0x00 2AB3 20 SHA3 2AB4 80 DUP1 2AB5 54 SLOAD 2AB6 90 SWAP1 2AB7 50 POP 2AB8 61 PUSH2 0x2e3f 2ABB 90 SWAP1 2ABC 91 SWAP2 2ABD 90 SWAP1 2ABE 63 PUSH4 0xffffffff 2AC3 16 AND 2AC4 56 *JUMP // Stack delta = +2 // Outputs[11] // { // @2A13 memory[0x00:0x20] = stack[-2] // @2A26 storage[0x02 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x00] = 0x00 // @2A2E storage[0x02 * stack[-1] + keccak256(memory[0x00:0x20]) + 0x01] = 0x00 // @2A63 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @2A69 memory[0x20:0x40] = 0x0a // @2A6F stack[-2] = keccak256(memory[0x00:0x40]) // @2A70 stack[-1] = 0x2ac5 // @2AA7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @2AAD memory[0x20:0x40] = 0x0a // @2ABC stack[0] = storage[keccak256(memory[0x00:0x40])] // @2ABD stack[1] = 0x01 // } // Block ends with call to 0xffffffff & 0x2e3f, returns to 0x2AC5 label_2AC5: // Incoming return from call to 0x2E3F at 0x2AC4 // Inputs[3] // { // @2AC6 stack[-2] // @2AC7 storage[stack[-2]] // @2AC8 stack[-1] // } 2AC5 5B JUMPDEST 2AC6 81 DUP2 2AC7 54 SLOAD 2AC8 81 DUP2 2AC9 10 LT 2ACA 61 PUSH2 0x2acf 2ACD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2acf, if stack[-1] < storage[stack[-2]] label_2ACE: // Incoming jump from 0x2ACD, if not stack[-1] < storage[stack[-2]] 2ACE FE *ASSERT // Stack delta = +0 // Outputs[1] { @2ACE assert(); } // Block terminates label_2ACF: // Incoming jump from 0x2ACD, if stack[-1] < storage[stack[-2]] // Inputs[7] // { // @2AD0 stack[-2] // @2AD0 stack[-1] // @2AD8 memory[0x00:0x20] // @2AE2 stack[-7] // @2B1C memory[0x00:0x40] // @2B1D stack[-6] // @2B1F storage[keccak256(memory[0x00:0x40])] // } 2ACF 5B JUMPDEST 2AD0 90 SWAP1 2AD1 60 PUSH1 0x00 2AD3 52 MSTORE 2AD4 60 PUSH1 0x20 2AD6 60 PUSH1 0x00 2AD8 20 SHA3 2AD9 90 SWAP1 2ADA 60 PUSH1 0x02 2ADC 02 MUL 2ADD 01 ADD 2ADE 60 PUSH1 0x0a 2AE0 60 PUSH1 0x00 2AE2 87 DUP8 2AE3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2AF8 16 AND 2AF9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B0E 16 AND 2B0F 81 DUP2 2B10 52 MSTORE 2B11 60 PUSH1 0x20 2B13 01 ADD 2B14 90 SWAP1 2B15 81 DUP2 2B16 52 MSTORE 2B17 60 PUSH1 0x20 2B19 01 ADD 2B1A 60 PUSH1 0x00 2B1C 20 SHA3 2B1D 85 DUP6 2B1E 81 DUP2 2B1F 54 SLOAD 2B20 81 DUP2 2B21 10 LT 2B22 61 PUSH2 0x2b27 2B25 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @2AD3 memory[0x00:0x20] = stack[-2] // @2ADD stack[-2] = 0x02 * stack[-1] + keccak256(memory[0x00:0x20]) // @2B10 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @2B16 memory[0x20:0x40] = 0x0a // @2B1C stack[-1] = keccak256(memory[0x00:0x40]) // @2B1D stack[0] = stack[-6] // } // Block ends with conditional jump to 0x2b27, if stack[-6] < storage[keccak256(memory[0x00:0x40])] label_2B26: // Incoming jump from 0x2B25, if not stack[-6] < storage[keccak256(memory[0x00:0x40])] 2B26 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2B26 assert(); } // Block terminates label_2B27: // Incoming jump from 0x2B25, if stack[-6] < storage[keccak256(memory[0x00:0x40])] // Inputs[9] // { // @2B28 stack[-1] // @2B28 stack[-2] // @2B30 memory[0x00:0x20] // @2B38 stack[-3] // @2B3A storage[stack[-3] + 0x00] // @2B44 storage[stack[-3] + 0x01] // @2B53 stack[-8] // @2B8D memory[0x00:0x40] // @2B91 storage[keccak256(memory[0x00:0x40])] // } 2B27 5B JUMPDEST 2B28 90 SWAP1 2B29 60 PUSH1 0x00 2B2B 52 MSTORE 2B2C 60 PUSH1 0x20 2B2E 60 PUSH1 0x00 2B30 20 SHA3 2B31 90 SWAP1 2B32 60 PUSH1 0x02 2B34 02 MUL 2B35 01 ADD 2B36 60 PUSH1 0x00 2B38 82 DUP3 2B39 01 ADD 2B3A 54 SLOAD 2B3B 81 DUP2 2B3C 60 PUSH1 0x00 2B3E 01 ADD 2B3F 55 SSTORE 2B40 60 PUSH1 0x01 2B42 82 DUP3 2B43 01 ADD 2B44 54 SLOAD 2B45 81 DUP2 2B46 60 PUSH1 0x01 2B48 01 ADD 2B49 55 SSTORE 2B4A 90 SWAP1 2B4B 50 POP 2B4C 50 POP 2B4D 60 PUSH1 0x01 2B4F 60 PUSH1 0x0a 2B51 60 PUSH1 0x00 2B53 87 DUP8 2B54 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B69 16 AND 2B6A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B7F 16 AND 2B80 81 DUP2 2B81 52 MSTORE 2B82 60 PUSH1 0x20 2B84 01 ADD 2B85 90 SWAP1 2B86 81 DUP2 2B87 52 MSTORE 2B88 60 PUSH1 0x20 2B8A 01 ADD 2B8B 60 PUSH1 0x00 2B8D 20 SHA3 2B8E 81 DUP2 2B8F 81 DUP2 2B90 80 DUP1 2B91 54 SLOAD 2B92 90 SWAP1 2B93 50 POP 2B94 03 SUB 2B95 91 SWAP2 2B96 50 POP 2B97 81 DUP2 2B98 61 PUSH2 0x2ba1 2B9B 91 SWAP2 2B9C 90 SWAP1 2B9D 61 PUSH2 0x355f 2BA0 56 *JUMP // Stack delta = +1 // Outputs[9] // { // @2B2B memory[0x00:0x20] = stack[-2] // @2B3F storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] = storage[stack[-3] + 0x00] // @2B49 storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] = storage[stack[-3] + 0x01] // @2B81 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-8] // @2B87 memory[0x20:0x40] = 0x0a // @2B95 stack[-3] = storage[keccak256(memory[0x00:0x40])] - 0x01 // @2B9B stack[-2] = 0x2ba1 // @2B9C stack[-1] = keccak256(memory[0x00:0x40]) // @2B9C stack[0] = storage[keccak256(memory[0x00:0x40])] - 0x01 // } // Block ends with call to 0x355f, returns to 0x2BA1 label_2BA1: // Incoming return from call to 0x355F at 0x2BA0 // Inputs[7] // { // @2BA3 stack[-6] // @2BDB stack[-2] // @2BDE memory[0x40:0x60] // @2BEB memory[0x40:0x60] // @2BF0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @2C33 memory[0x00:0x40] // @2C34 storage[keccak256(memory[0x00:0x40])] // } 2BA1 5B JUMPDEST 2BA2 50 POP 2BA3 84 DUP5 2BA4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BB9 16 AND 2BBA 7F PUSH32 0x6381d9813cabeb57471b5a7e05078e64845ccdb563146a6911d536f24ce960f1 2BDB 82 DUP3 2BDC 60 PUSH1 0x40 2BDE 51 MLOAD 2BDF 80 DUP1 2BE0 82 DUP3 2BE1 81 DUP2 2BE2 52 MSTORE 2BE3 60 PUSH1 0x20 2BE5 01 ADD 2BE6 91 SWAP2 2BE7 50 POP 2BE8 50 POP 2BE9 60 PUSH1 0x40 2BEB 51 MLOAD 2BEC 80 DUP1 2BED 91 SWAP2 2BEE 03 SUB 2BEF 90 SWAP1 2BF0 A2 LOG2 2BF1 61 PUSH2 0x2c42 2BF4 81 DUP2 2BF5 60 PUSH1 0x03 2BF7 60 PUSH1 0x00 2BF9 88 DUP9 2BFA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C0F 16 AND 2C10 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C25 16 AND 2C26 81 DUP2 2C27 52 MSTORE 2C28 60 PUSH1 0x20 2C2A 01 ADD 2C2B 90 SWAP1 2C2C 81 DUP2 2C2D 52 MSTORE 2C2E 60 PUSH1 0x20 2C30 01 ADD 2C31 60 PUSH1 0x00 2C33 20 SHA3 2C34 54 SLOAD 2C35 61 PUSH2 0x26b7 2C38 90 SWAP1 2C39 91 SWAP2 2C3A 90 SWAP1 2C3B 63 PUSH4 0xffffffff 2C40 16 AND 2C41 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @2BE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @2BF0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x6381d9813cabeb57471b5a7e05078e64845ccdb563146a6911d536f24ce960f1, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff]); // @2BF1 stack[-1] = 0x2c42 // @2C27 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2C2D memory[0x20:0x40] = 0x03 // @2C39 stack[0] = storage[keccak256(memory[0x00:0x40])] // @2C3A stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x26b7, returns to 0x2C42 label_2C42: // Incoming return from call to 0x26B7 at 0x2C41 // Inputs[5] // { // @2C47 stack[-6] // @2C81 memory[0x00:0x40] // @2C82 stack[-1] // @2C88 stack[-4] // @2C8C stack[-7] // } 2C42 5B JUMPDEST 2C43 60 PUSH1 0x03 2C45 60 PUSH1 0x00 2C47 87 DUP8 2C48 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C5D 16 AND 2C5E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C73 16 AND 2C74 81 DUP2 2C75 52 MSTORE 2C76 60 PUSH1 0x20 2C78 01 ADD 2C79 90 SWAP1 2C7A 81 DUP2 2C7B 52 MSTORE 2C7C 60 PUSH1 0x20 2C7E 01 ADD 2C7F 60 PUSH1 0x00 2C81 20 SHA3 2C82 81 DUP2 2C83 90 SWAP1 2C84 55 SSTORE 2C85 50 POP 2C86 60 PUSH1 0x01 2C88 92 SWAP3 2C89 50 POP 2C8A 50 POP 2C8B 50 POP 2C8C 92 SWAP3 2C8D 91 SWAP2 2C8E 50 POP 2C8F 50 POP 2C90 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @2C75 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2C7B memory[0x20:0x40] = 0x03 // @2C84 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2C8C stack[-7] = 0x01 // } // Block ends with unconditional jump to stack[-7] label_2C91: // Incoming call from 0x1C56, returns to 0x1C57 // Inputs[1] { @2C95 stack[-1] } 2C91 5B JUMPDEST 2C92 61 PUSH2 0x2ca5 2C95 81 DUP2 2C96 60 PUSH1 0x08 2C98 61 PUSH2 0x349c 2C9B 90 SWAP1 2C9C 91 SWAP2 2C9D 90 SWAP1 2C9E 63 PUSH4 0xffffffff 2CA3 16 AND 2CA4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C92 stack[0] = 0x2ca5 // @2C9C stack[1] = 0x08 // @2C9D stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x349c, returns to 0x2CA5 label_2CA5: // Incoming return from call to 0x349C at 0x2CA4 // Inputs[5] // { // @2CA6 stack[-1] // @2CE0 memory[0x40:0x60] // @2CE3 memory[0x40:0x60] // @2CE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @2CEA stack[-2] // } 2CA5 5B JUMPDEST 2CA6 80 DUP1 2CA7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2CBC 16 AND 2CBD 7F PUSH32 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8 2CDE 60 PUSH1 0x40 2CE0 51 MLOAD 2CE1 60 PUSH1 0x40 2CE3 51 MLOAD 2CE4 80 DUP1 2CE5 91 SWAP2 2CE6 03 SUB 2CE7 90 SWAP1 2CE8 A2 LOG2 2CE9 50 POP 2CEA 56 *JUMP // Stack delta = -2 // Outputs[1] { @2CE8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); } // Block ends with unconditional jump to stack[-2] label_2CEB: // Incoming call from 0x1CBF, returns to 0x1CC0 // Inputs[1] { @2D04 stack[-2] } 2CEB 5B JUMPDEST 2CEC 60 PUSH1 0x00 2CEE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D03 16 AND 2D04 82 DUP3 2D05 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D1A 16 AND 2D1B 14 EQ 2D1C 15 ISZERO 2D1D 61 PUSH2 0x2d25 2D20 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2d25, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2D21: // Incoming jump from 0x2D20, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2D24 memory[0x00:0x00] } 2D21 60 PUSH1 0x00 2D23 80 DUP1 2D24 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D24 revert(memory[0x00:0x00]); } // Block terminates label_2D25: // Incoming jump from 0x2D20, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @2D29 stack[-1] // @2D2C storage[0x05] // } 2D25 5B JUMPDEST 2D26 61 PUSH2 0x2d3a 2D29 81 DUP2 2D2A 60 PUSH1 0x05 2D2C 54 SLOAD 2D2D 61 PUSH2 0x2e3f 2D30 90 SWAP1 2D31 91 SWAP2 2D32 90 SWAP1 2D33 63 PUSH4 0xffffffff 2D38 16 AND 2D39 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2D26 stack[0] = 0x2d3a // @2D31 stack[1] = storage[0x05] // @2D32 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x2e3f, returns to 0x2D3A label_2D3A: // Incoming return from call to 0x2E3F at 0x2D39 // Inputs[5] // { // @2D3D stack[-1] // @2D44 stack[-2] // @2D49 stack[-3] // @2D83 memory[0x00:0x40] // @2D84 storage[keccak256(memory[0x00:0x40])] // } 2D3A 5B JUMPDEST 2D3B 60 PUSH1 0x05 2D3D 81 DUP2 2D3E 90 SWAP1 2D3F 55 SSTORE 2D40 50 POP 2D41 61 PUSH2 0x2d92 2D44 81 DUP2 2D45 60 PUSH1 0x03 2D47 60 PUSH1 0x00 2D49 85 DUP6 2D4A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D5F 16 AND 2D60 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D75 16 AND 2D76 81 DUP2 2D77 52 MSTORE 2D78 60 PUSH1 0x20 2D7A 01 ADD 2D7B 90 SWAP1 2D7C 81 DUP2 2D7D 52 MSTORE 2D7E 60 PUSH1 0x20 2D80 01 ADD 2D81 60 PUSH1 0x00 2D83 20 SHA3 2D84 54 SLOAD 2D85 61 PUSH2 0x2e3f 2D88 90 SWAP1 2D89 91 SWAP2 2D8A 90 SWAP1 2D8B 63 PUSH4 0xffffffff 2D90 16 AND 2D91 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @2D3F storage[0x05] = stack[-1] // @2D41 stack[-1] = 0x2d92 // @2D77 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2D7D memory[0x20:0x40] = 0x03 // @2D89 stack[0] = storage[keccak256(memory[0x00:0x40])] // @2D8A stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x2e3f, returns to 0x2D92 label_2D92: // Incoming return from call to 0x2E3F at 0x2D91 // Inputs[8] // { // @2D97 stack[-3] // @2DD1 memory[0x00:0x40] // @2DD2 stack[-1] // @2E26 stack[-2] // @2E29 memory[0x40:0x60] // @2E36 memory[0x40:0x60] // @2E3B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @2E3E stack[-4] // } 2D92 5B JUMPDEST 2D93 60 PUSH1 0x03 2D95 60 PUSH1 0x00 2D97 84 DUP5 2D98 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2DAD 16 AND 2DAE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2DC3 16 AND 2DC4 81 DUP2 2DC5 52 MSTORE 2DC6 60 PUSH1 0x20 2DC8 01 ADD 2DC9 90 SWAP1 2DCA 81 DUP2 2DCB 52 MSTORE 2DCC 60 PUSH1 0x20 2DCE 01 ADD 2DCF 60 PUSH1 0x00 2DD1 20 SHA3 2DD2 81 DUP2 2DD3 90 SWAP1 2DD4 55 SSTORE 2DD5 50 POP 2DD6 60 PUSH1 0x00 2DD8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2DED 16 AND 2DEE 82 DUP3 2DEF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E04 16 AND 2E05 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2E26 83 DUP4 2E27 60 PUSH1 0x40 2E29 51 MLOAD 2E2A 80 DUP1 2E2B 82 DUP3 2E2C 81 DUP2 2E2D 52 MSTORE 2E2E 60 PUSH1 0x20 2E30 01 ADD 2E31 91 SWAP2 2E32 50 POP 2E33 50 POP 2E34 60 PUSH1 0x40 2E36 51 MLOAD 2E37 80 DUP1 2E38 91 SWAP2 2E39 03 SUB 2E3A 90 SWAP1 2E3B A3 LOG3 2E3C 50 POP 2E3D 50 POP 2E3E 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @2DC5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2DCB memory[0x20:0x40] = 0x03 // @2DD4 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2E2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @2E3B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); // } // Block ends with unconditional jump to stack[-4] label_2E3F: // Incoming call from 0x1F17, returns to 0x1F18 // Incoming call from 0x2D91, returns to 0x2D92 // Incoming call from 0x2AC4, returns to 0x2AC5 // Incoming call from 0x3279, returns to 0x327A // Incoming call from 0x2F18, returns to 0x2F19 // Incoming call from 0x30AE, returns to 0x30AF // Incoming call from 0x2D39, returns to 0x2D3A // Inputs[2] // { // @2E42 stack[-2] // @2E43 stack[-1] // } 2E3F 5B JUMPDEST 2E40 60 PUSH1 0x00 2E42 82 DUP3 2E43 82 DUP3 2E44 11 GT 2E45 15 ISZERO 2E46 61 PUSH2 0x2e4e 2E49 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2E40 stack[0] = 0x00 } // Block ends with conditional jump to 0x2e4e, if !(stack[-1] > stack[-2]) label_2E4A: // Incoming jump from 0x2E49, if not !(stack[-1] > stack[-2]) // Inputs[1] { @2E4D memory[0x00:0x00] } 2E4A 60 PUSH1 0x00 2E4C 80 DUP1 2E4D FD *REVERT // Stack delta = +0 // Outputs[1] { @2E4D revert(memory[0x00:0x00]); } // Block terminates label_2E4E: // Incoming jump from 0x2E49, if !(stack[-1] > stack[-2]) // Inputs[4] // { // @2E51 stack[-2] // @2E52 stack[-3] // @2E57 stack[-1] // @2E5A stack[-4] // } 2E4E 5B JUMPDEST 2E4F 60 PUSH1 0x00 2E51 82 DUP3 2E52 84 DUP5 2E53 03 SUB 2E54 90 SWAP1 2E55 50 POP 2E56 80 DUP1 2E57 91 SWAP2 2E58 50 POP 2E59 50 POP 2E5A 92 SWAP3 2E5B 91 SWAP2 2E5C 50 POP 2E5D 50 POP 2E5E 56 *JUMP // Stack delta = -3 // Outputs[1] { @2E5A stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_2E5F: // Incoming call from 0x213C, returns to 0x213D // Inputs[1] { @2E67 storage[0x09] } 2E5F 5B JUMPDEST 2E60 60 PUSH1 0x00 2E62 60 PUSH1 0x09 2E64 60 PUSH1 0x00 2E66 90 SWAP1 2E67 54 SLOAD 2E68 90 SWAP1 2E69 61 PUSH2 0x0100 2E6C 0A EXP 2E6D 90 SWAP1 2E6E 04 DIV 2E6F 60 PUSH1 0xff 2E71 16 AND 2E72 15 ISZERO 2E73 61 PUSH2 0x2e7b 2E76 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2E60 stack[0] = 0x00 } // Block ends with conditional jump to 0x2e7b, if !(0xff & storage[0x09] / 0x0100 ** 0x00) label_2E77: // Incoming jump from 0x2E76, if not !(0xff & storage[0x09] / 0x0100 ** 0x00) // Inputs[1] { @2E7A memory[0x00:0x00] } 2E77 60 PUSH1 0x00 2E79 80 DUP1 2E7A FD *REVERT // Stack delta = +0 // Outputs[1] { @2E7A revert(memory[0x00:0x00]); } // Block terminates label_2E7B: // Incoming jump from 0x2E76, if !(0xff & storage[0x09] / 0x0100 ** 0x00) // Inputs[2] // { // @2E7F stack[-3] // @2E80 stack[-2] // } 2E7B 5B JUMPDEST 2E7C 61 PUSH2 0x2e85 2E7F 83 DUP4 2E80 83 DUP4 2E81 61 PUSH2 0x3548 2E84 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2E7C stack[0] = 0x2e85 // @2E7F stack[1] = stack[-3] // @2E80 stack[2] = stack[-2] // } // Block ends with call to 0x3548, returns to 0x2E85 label_2E85: // Incoming return from call to 0x3548 at 0x2E84 // Inputs[4] // { // @2E86 stack[-2] // @2E86 stack[-1] // @2E88 stack[-5] // @2E89 stack[-4] // } 2E85 5B JUMPDEST 2E86 90 SWAP1 2E87 50 POP 2E88 92 SWAP3 2E89 91 SWAP2 2E8A 50 POP 2E8B 50 POP 2E8C 56 *JUMP // Stack delta = -4 // Outputs[1] { @2E88 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2E8D: // Incoming call from 0x227F, returns to 0x2280 // Incoming call from 0x3304, returns to 0x3305 // Incoming call from 0x3554, returns to 0x3555 // Inputs[1] { @2EA6 stack[-2] } 2E8D 5B JUMPDEST 2E8E 60 PUSH1 0x00 2E90 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2EA5 16 AND 2EA6 82 DUP3 2EA7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2EBC 16 AND 2EBD 14 EQ 2EBE 15 ISZERO 2EBF 61 PUSH2 0x2ec7 2EC2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2ec7, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2EC3: // Incoming jump from 0x2EC2, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2EC6 memory[0x00:0x00] } 2EC3 60 PUSH1 0x00 2EC5 80 DUP1 2EC6 FD *REVERT // Stack delta = +0 // Outputs[1] { @2EC6 revert(memory[0x00:0x00]); } // Block terminates label_2EC7: // Incoming jump from 0x2EC2, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @2ECB stack[-1] // @2ED0 stack[-3] // @2F0A memory[0x00:0x40] // @2F0B storage[keccak256(memory[0x00:0x40])] // } 2EC7 5B JUMPDEST 2EC8 61 PUSH2 0x2f19 2ECB 81 DUP2 2ECC 60 PUSH1 0x03 2ECE 60 PUSH1 0x00 2ED0 86 DUP7 2ED1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2EE6 16 AND 2EE7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2EFC 16 AND 2EFD 81 DUP2 2EFE 52 MSTORE 2EFF 60 PUSH1 0x20 2F01 01 ADD 2F02 90 SWAP1 2F03 81 DUP2 2F04 52 MSTORE 2F05 60 PUSH1 0x20 2F07 01 ADD 2F08 60 PUSH1 0x00 2F0A 20 SHA3 2F0B 54 SLOAD 2F0C 61 PUSH2 0x2e3f 2F0F 90 SWAP1 2F10 91 SWAP2 2F11 90 SWAP1 2F12 63 PUSH4 0xffffffff 2F17 16 AND 2F18 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2EC8 stack[0] = 0x2f19 // @2EFE memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2F04 memory[0x20:0x40] = 0x03 // @2F10 stack[1] = storage[keccak256(memory[0x00:0x40])] // @2F11 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x2e3f, returns to 0x2F19 label_2F19: // Incoming return from call to 0x2E3F at 0x2F18 // Inputs[7] // { // @2F1E stack[-4] // @2F58 memory[0x00:0x40] // @2F59 stack[-1] // @2F60 stack[-2] // @2F65 stack[-3] // @2F9F memory[0x00:0x40] // @2FA0 storage[keccak256(memory[0x00:0x40])] // } 2F19 5B JUMPDEST 2F1A 60 PUSH1 0x03 2F1C 60 PUSH1 0x00 2F1E 85 DUP6 2F1F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F34 16 AND 2F35 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F4A 16 AND 2F4B 81 DUP2 2F4C 52 MSTORE 2F4D 60 PUSH1 0x20 2F4F 01 ADD 2F50 90 SWAP1 2F51 81 DUP2 2F52 52 MSTORE 2F53 60 PUSH1 0x20 2F55 01 ADD 2F56 60 PUSH1 0x00 2F58 20 SHA3 2F59 81 DUP2 2F5A 90 SWAP1 2F5B 55 SSTORE 2F5C 50 POP 2F5D 61 PUSH2 0x2fae 2F60 81 DUP2 2F61 60 PUSH1 0x03 2F63 60 PUSH1 0x00 2F65 85 DUP6 2F66 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F7B 16 AND 2F7C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F91 16 AND 2F92 81 DUP2 2F93 52 MSTORE 2F94 60 PUSH1 0x20 2F96 01 ADD 2F97 90 SWAP1 2F98 81 DUP2 2F99 52 MSTORE 2F9A 60 PUSH1 0x20 2F9C 01 ADD 2F9D 60 PUSH1 0x00 2F9F 20 SHA3 2FA0 54 SLOAD 2FA1 61 PUSH2 0x26b7 2FA4 90 SWAP1 2FA5 91 SWAP2 2FA6 90 SWAP1 2FA7 63 PUSH4 0xffffffff 2FAC 16 AND 2FAD 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @2F4C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @2F52 memory[0x20:0x40] = 0x03 // @2F5B storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2F5D stack[-1] = 0x2fae // @2F93 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2F99 memory[0x20:0x40] = 0x03 // @2FA5 stack[0] = storage[keccak256(memory[0x00:0x40])] // @2FA6 stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x26b7, returns to 0x2FAE label_2FAE: // Incoming return from call to 0x26B7 at 0x2FAD // Inputs[9] // { // @2FB3 stack[-3] // @2FED memory[0x00:0x40] // @2FEE stack[-1] // @3009 stack[-4] // @3041 stack[-2] // @3044 memory[0x40:0x60] // @3051 memory[0x40:0x60] // @3056 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @305A stack[-5] // } 2FAE 5B JUMPDEST 2FAF 60 PUSH1 0x03 2FB1 60 PUSH1 0x00 2FB3 84 DUP5 2FB4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2FC9 16 AND 2FCA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2FDF 16 AND 2FE0 81 DUP2 2FE1 52 MSTORE 2FE2 60 PUSH1 0x20 2FE4 01 ADD 2FE5 90 SWAP1 2FE6 81 DUP2 2FE7 52 MSTORE 2FE8 60 PUSH1 0x20 2FEA 01 ADD 2FEB 60 PUSH1 0x00 2FED 20 SHA3 2FEE 81 DUP2 2FEF 90 SWAP1 2FF0 55 SSTORE 2FF1 50 POP 2FF2 81 DUP2 2FF3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3008 16 AND 3009 83 DUP4 300A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 301F 16 AND 3020 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 3041 83 DUP4 3042 60 PUSH1 0x40 3044 51 MLOAD 3045 80 DUP1 3046 82 DUP3 3047 81 DUP2 3048 52 MSTORE 3049 60 PUSH1 0x20 304B 01 ADD 304C 91 SWAP2 304D 50 POP 304E 50 POP 304F 60 PUSH1 0x40 3051 51 MLOAD 3052 80 DUP1 3053 91 SWAP2 3054 03 SUB 3055 90 SWAP1 3056 A3 LOG3 3057 50 POP 3058 50 POP 3059 50 POP 305A 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @2FE1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2FE7 memory[0x20:0x40] = 0x03 // @2FF0 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @3048 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @3056 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-5] label_305B: // Incoming call from 0x228A, returns to 0x228B // Incoming call from 0x235D, returns to 0x235E // Inputs[4] // { // @3061 stack[-2] // @3066 stack[-3] // @30A0 memory[0x00:0x40] // @30A1 storage[keccak256(memory[0x00:0x40])] // } 305B 5B JUMPDEST 305C 60 PUSH1 0x00 305E 61 PUSH2 0x30af 3061 83 DUP4 3062 60 PUSH1 0x03 3064 60 PUSH1 0x00 3066 87 DUP8 3067 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 307C 16 AND 307D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3092 16 AND 3093 81 DUP2 3094 52 MSTORE 3095 60 PUSH1 0x20 3097 01 ADD 3098 90 SWAP1 3099 81 DUP2 309A 52 MSTORE 309B 60 PUSH1 0x20 309D 01 ADD 309E 60 PUSH1 0x00 30A0 20 SHA3 30A1 54 SLOAD 30A2 61 PUSH2 0x2e3f 30A5 90 SWAP1 30A6 91 SWAP2 30A7 90 SWAP1 30A8 63 PUSH4 0xffffffff 30AD 16 AND 30AE 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @305C stack[0] = 0x00 // @305E stack[1] = 0x30af // @3094 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @309A memory[0x20:0x40] = 0x03 // @30A6 stack[2] = storage[keccak256(memory[0x00:0x40])] // @30A7 stack[3] = stack[-2] // } // Block ends with call to 0xffffffff & 0x2e3f, returns to 0x30AF label_30AF: // Incoming return from call to 0x2E3F at 0x30AE // Inputs[16] // { // @30B4 stack[-5] // @30EE memory[0x00:0x40] // @30EF stack[-1] // @3131 memory[0x00:0x40] // @3134 memory[0x40:0x60] // @313D stack[-3] // @3143 stack[-4] // @314C storage[keccak256(memory[0x00:0x40])] // @3162 memory[0x00:0x20] // @3176 memory[memory[0x40:0x60] + 0x00:memory[0x40:0x60] + 0x00 + 0x20] // @3180 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @31C5 memory[0x40:0x60] // @31D9 memory[0x40:0x60] // @31DE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @31E1 stack[-2] // @31E3 stack[-6] // } 30AF 5B JUMPDEST 30B0 60 PUSH1 0x03 30B2 60 PUSH1 0x00 30B4 86 DUP7 30B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30CA 16 AND 30CB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30E0 16 AND 30E1 81 DUP2 30E2 52 MSTORE 30E3 60 PUSH1 0x20 30E5 01 ADD 30E6 90 SWAP1 30E7 81 DUP2 30E8 52 MSTORE 30E9 60 PUSH1 0x20 30EB 01 ADD 30EC 60 PUSH1 0x00 30EE 20 SHA3 30EF 81 DUP2 30F0 90 SWAP1 30F1 55 SSTORE 30F2 50 POP 30F3 60 PUSH1 0x0a 30F5 60 PUSH1 0x00 30F7 85 DUP6 30F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 310D 16 AND 310E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3123 16 AND 3124 81 DUP2 3125 52 MSTORE 3126 60 PUSH1 0x20 3128 01 ADD 3129 90 SWAP1 312A 81 DUP2 312B 52 MSTORE 312C 60 PUSH1 0x20 312E 01 ADD 312F 60 PUSH1 0x00 3131 20 SHA3 3132 60 PUSH1 0x40 3134 51 MLOAD 3135 80 DUP1 3136 60 PUSH1 0x40 3138 01 ADD 3139 60 PUSH1 0x40 313B 52 MSTORE 313C 80 DUP1 313D 84 DUP5 313E 81 DUP2 313F 52 MSTORE 3140 60 PUSH1 0x20 3142 01 ADD 3143 85 DUP6 3144 81 DUP2 3145 52 MSTORE 3146 50 POP 3147 90 SWAP1 3148 80 DUP1 3149 60 PUSH1 0x01 314B 81 DUP2 314C 54 SLOAD 314D 01 ADD 314E 80 DUP1 314F 82 DUP3 3150 55 SSTORE 3151 80 DUP1 3152 91 SWAP2 3153 50 POP 3154 50 POP 3155 90 SWAP1 3156 60 PUSH1 0x01 3158 82 DUP3 3159 03 SUB 315A 90 SWAP1 315B 60 PUSH1 0x00 315D 52 MSTORE 315E 60 PUSH1 0x20 3160 60 PUSH1 0x00 3162 20 SHA3 3163 90 SWAP1 3164 60 PUSH1 0x02 3166 02 MUL 3167 01 ADD 3168 60 PUSH1 0x00 316A 90 SWAP1 316B 91 SWAP2 316C 92 SWAP3 316D 90 SWAP1 316E 91 SWAP2 316F 90 SWAP1 3170 91 SWAP2 3171 50 POP 3172 60 PUSH1 0x00 3174 82 DUP3 3175 01 ADD 3176 51 MLOAD 3177 81 DUP2 3178 60 PUSH1 0x00 317A 01 ADD 317B 55 SSTORE 317C 60 PUSH1 0x20 317E 82 DUP3 317F 01 ADD 3180 51 MLOAD 3181 81 DUP2 3182 60 PUSH1 0x01 3184 01 ADD 3185 55 SSTORE 3186 50 POP 3187 50 POP 3188 50 POP 3189 83 DUP4 318A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 319F 16 AND 31A0 7F PUSH32 0x49eaf4942f1237055eb4cfa5f31c9dfe50d5b4ade01e021f7de8be2fbbde557b 31C1 84 DUP5 31C2 84 DUP5 31C3 60 PUSH1 0x40 31C5 51 MLOAD 31C6 80 DUP1 31C7 83 DUP4 31C8 81 DUP2 31C9 52 MSTORE 31CA 60 PUSH1 0x20 31CC 01 ADD 31CD 82 DUP3 31CE 81 DUP2 31CF 52 MSTORE 31D0 60 PUSH1 0x20 31D2 01 ADD 31D3 92 SWAP3 31D4 50 POP 31D5 50 POP 31D6 50 POP 31D7 60 PUSH1 0x40 31D9 51 MLOAD 31DA 80 DUP1 31DB 91 SWAP2 31DC 03 SUB 31DD 90 SWAP1 31DE A2 LOG2 31DF 60 PUSH1 0x01 31E1 90 SWAP1 31E2 50 POP 31E3 93 SWAP4 31E4 92 SWAP3 31E5 50 POP 31E6 50 POP 31E7 50 POP 31E8 56 *JUMP // Stack delta = -5 // Outputs[16] // { // @30E2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @30E8 memory[0x20:0x40] = 0x03 // @30F1 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @3125 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @312B memory[0x20:0x40] = 0x0a // @313B memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @313F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @3145 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-4] // @3150 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @315D memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @317B storage[0x00 + 0x02 * ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])] = memory[memory[0x40:0x60] + 0x00:memory[0x40:0x60] + 0x00 + 0x20] // @3185 storage[0x01 + 0x02 * ((storage[keccak256(memory[0x00:0x40])] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])] = memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @31C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @31CF memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-3] // @31DE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x49eaf4942f1237055eb4cfa5f31c9dfe50d5b4ade01e021f7de8be2fbbde557b, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff]); // @31E3 stack[-6] = 0x01 // } // Block ends with unconditional jump to stack[-6] label_31E9: // Incoming call from 0x2669, returns to 0x266A // Inputs[6] // { // @31EF stack[-1] // @31F4 stack[-3] // @322E memory[0x00:0x40] // @3231 msg.sender // @326B memory[0x00:0x40] // @326C storage[keccak256(memory[0x00:0x40])] // } 31E9 5B JUMPDEST 31EA 60 PUSH1 0x00 31EC 61 PUSH2 0x327a 31EF 82 DUP3 31F0 60 PUSH1 0x04 31F2 60 PUSH1 0x00 31F4 87 DUP8 31F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 320A 16 AND 320B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3220 16 AND 3221 81 DUP2 3222 52 MSTORE 3223 60 PUSH1 0x20 3225 01 ADD 3226 90 SWAP1 3227 81 DUP2 3228 52 MSTORE 3229 60 PUSH1 0x20 322B 01 ADD 322C 60 PUSH1 0x00 322E 20 SHA3 322F 60 PUSH1 0x00 3231 33 CALLER 3232 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3247 16 AND 3248 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 325D 16 AND 325E 81 DUP2 325F 52 MSTORE 3260 60 PUSH1 0x20 3262 01 ADD 3263 90 SWAP1 3264 81 DUP2 3265 52 MSTORE 3266 60 PUSH1 0x20 3268 01 ADD 3269 60 PUSH1 0x00 326B 20 SHA3 326C 54 SLOAD 326D 61 PUSH2 0x2e3f 3270 90 SWAP1 3271 91 SWAP2 3272 90 SWAP1 3273 63 PUSH4 0xffffffff 3278 16 AND 3279 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @31EA stack[0] = 0x00 // @31EC stack[1] = 0x327a // @3222 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @3228 memory[0x20:0x40] = 0x04 // @325F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @3265 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3271 stack[2] = storage[keccak256(memory[0x00:0x40])] // @3272 stack[3] = stack[-1] // } // Block ends with call to 0xffffffff & 0x2e3f, returns to 0x327A label_327A: // Incoming return from call to 0x2E3F at 0x3279 // Inputs[7] // { // @327F stack[-5] // @32B9 memory[0x00:0x40] // @32BC msg.sender // @32F6 memory[0x00:0x40] // @32F7 stack[-1] // @32FF stack[-4] // @3300 stack[-3] // } 327A 5B JUMPDEST 327B 60 PUSH1 0x04 327D 60 PUSH1 0x00 327F 86 DUP7 3280 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3295 16 AND 3296 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 32AB 16 AND 32AC 81 DUP2 32AD 52 MSTORE 32AE 60 PUSH1 0x20 32B0 01 ADD 32B1 90 SWAP1 32B2 81 DUP2 32B3 52 MSTORE 32B4 60 PUSH1 0x20 32B6 01 ADD 32B7 60 PUSH1 0x00 32B9 20 SHA3 32BA 60 PUSH1 0x00 32BC 33 CALLER 32BD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 32D2 16 AND 32D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 32E8 16 AND 32E9 81 DUP2 32EA 52 MSTORE 32EB 60 PUSH1 0x20 32ED 01 ADD 32EE 90 SWAP1 32EF 81 DUP2 32F0 52 MSTORE 32F1 60 PUSH1 0x20 32F3 01 ADD 32F4 60 PUSH1 0x00 32F6 20 SHA3 32F7 81 DUP2 32F8 90 SWAP1 32F9 55 SSTORE 32FA 50 POP 32FB 61 PUSH2 0x3305 32FE 84 DUP5 32FF 84 DUP5 3300 84 DUP5 3301 61 PUSH2 0x2e8d 3304 56 *JUMP // Stack delta = +3 // Outputs[9] // { // @32AD memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @32B3 memory[0x20:0x40] = 0x04 // @32EA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @32F0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @32F9 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @32FB stack[-1] = 0x3305 // @32FE stack[0] = stack[-5] // @32FF stack[1] = stack[-4] // @3300 stack[2] = stack[-3] // } // Block ends with call to 0x2e8d, returns to 0x3305 label_3305: // Incoming return from call to 0x2E8D at 0x3304 // Inputs[11] // { // @3306 msg.sender // @331D stack[-4] // @3393 memory[0x00:0x40] // @3396 msg.sender // @33D0 memory[0x00:0x40] // @33D1 storage[keccak256(memory[0x00:0x40])] // @33D4 memory[0x40:0x60] // @33E1 memory[0x40:0x60] // @33E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @33E9 stack[-1] // @33EB stack[-5] // } 3305 5B JUMPDEST 3306 33 CALLER 3307 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 331C 16 AND 331D 84 DUP5 331E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3333 16 AND 3334 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 3355 60 PUSH1 0x04 3357 60 PUSH1 0x00 3359 88 DUP9 335A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 336F 16 AND 3370 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3385 16 AND 3386 81 DUP2 3387 52 MSTORE 3388 60 PUSH1 0x20 338A 01 ADD 338B 90 SWAP1 338C 81 DUP2 338D 52 MSTORE 338E 60 PUSH1 0x20 3390 01 ADD 3391 60 PUSH1 0x00 3393 20 SHA3 3394 60 PUSH1 0x00 3396 33 CALLER 3397 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 33AC 16 AND 33AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 33C2 16 AND 33C3 81 DUP2 33C4 52 MSTORE 33C5 60 PUSH1 0x20 33C7 01 ADD 33C8 90 SWAP1 33C9 81 DUP2 33CA 52 MSTORE 33CB 60 PUSH1 0x20 33CD 01 ADD 33CE 60 PUSH1 0x00 33D0 20 SHA3 33D1 54 SLOAD 33D2 60 PUSH1 0x40 33D4 51 MLOAD 33D5 80 DUP1 33D6 82 DUP3 33D7 81 DUP2 33D8 52 MSTORE 33D9 60 PUSH1 0x20 33DB 01 ADD 33DC 91 SWAP2 33DD 50 POP 33DE 50 POP 33DF 60 PUSH1 0x40 33E1 51 MLOAD 33E2 80 DUP1 33E3 91 SWAP2 33E4 03 SUB 33E5 90 SWAP1 33E6 A3 LOG3 33E7 60 PUSH1 0x01 33E9 90 SWAP1 33EA 50 POP 33EB 93 SWAP4 33EC 92 SWAP3 33ED 50 POP 33EE 50 POP 33EF 50 POP 33F0 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @3387 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @338D memory[0x20:0x40] = 0x04 // @33C4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @33CA memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @33D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @33E6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, msg.sender]); // @33EB stack[-5] = 0x01 // } // Block ends with unconditional jump to stack[-5] label_33F1: // Incoming call from 0x28CF, returns to 0x28D0 // Inputs[1] { @340A stack[-1] } 33F1 5B JUMPDEST 33F2 60 PUSH1 0x00 33F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3409 16 AND 340A 81 DUP2 340B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3420 16 AND 3421 14 EQ 3422 15 ISZERO 3423 61 PUSH2 0x342b 3426 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x342b, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_3427: // Incoming jump from 0x3426, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @342A memory[0x00:0x00] } 3427 60 PUSH1 0x00 3429 80 DUP1 342A FD *REVERT // Stack delta = +0 // Outputs[1] { @342A revert(memory[0x00:0x00]); } // Block terminates label_342B: // Incoming jump from 0x3426, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @342F stack[-2] // @3430 stack[-1] // } 342B 5B JUMPDEST 342C 61 PUSH2 0x3435 342F 82 DUP3 3430 82 DUP3 3431 61 PUSH2 0x282a 3434 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @342C stack[0] = 0x3435 // @342F stack[1] = stack[-2] // @3430 stack[2] = stack[-1] // } // Block ends with call to 0x282a, returns to 0x3435 label_3435: // Incoming return from call to 0x282A at 0x3434 // Inputs[1] { @3439 stack[-1] } 3435 5B JUMPDEST 3436 61 PUSH2 0x343e 3439 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x343e, if stack[-1] label_343A: // Incoming jump from 0x3439, if not stack[-1] // Inputs[1] { @343D memory[0x00:0x00] } 343A 60 PUSH1 0x00 343C 80 DUP1 343D FD *REVERT // Stack delta = +0 // Outputs[1] { @343D revert(memory[0x00:0x00]); } // Block terminates label_343E: // Incoming jump from 0x3439, if stack[-1] // Inputs[5] // { // @3441 stack[-2] // @3447 stack[-1] // @3481 memory[0x00:0x40] // @3489 storage[keccak256(memory[0x00:0x40])] // @349B stack[-3] // } 343E 5B JUMPDEST 343F 60 PUSH1 0x00 3441 82 DUP3 3442 60 PUSH1 0x00 3444 01 ADD 3445 60 PUSH1 0x00 3447 83 DUP4 3448 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 345D 16 AND 345E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3473 16 AND 3474 81 DUP2 3475 52 MSTORE 3476 60 PUSH1 0x20 3478 01 ADD 3479 90 SWAP1 347A 81 DUP2 347B 52 MSTORE 347C 60 PUSH1 0x20 347E 01 ADD 347F 60 PUSH1 0x00 3481 20 SHA3 3482 60 PUSH1 0x00 3484 61 PUSH2 0x0100 3487 0A EXP 3488 81 DUP2 3489 54 SLOAD 348A 81 DUP2 348B 60 PUSH1 0xff 348D 02 MUL 348E 19 NOT 348F 16 AND 3490 90 SWAP1 3491 83 DUP4 3492 15 ISZERO 3493 15 ISZERO 3494 02 MUL 3495 17 OR 3496 90 SWAP1 3497 55 SSTORE 3498 50 POP 3499 50 POP 349A 50 POP 349B 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3475 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @347B memory[0x20:0x40] = 0x00 + stack[-2] // @3497 storage[keccak256(memory[0x00:0x40])] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-3] label_349C: // Incoming call from 0x2CA4, returns to 0x2CA5 // Inputs[1] { @34B5 stack[-1] } 349C 5B JUMPDEST 349D 60 PUSH1 0x00 349F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 34B4 16 AND 34B5 81 DUP2 34B6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 34CB 16 AND 34CC 14 EQ 34CD 15 ISZERO 34CE 61 PUSH2 0x34d6 34D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x34d6, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_34D2: // Incoming jump from 0x34D1, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @34D5 memory[0x00:0x00] } 34D2 60 PUSH1 0x00 34D4 80 DUP1 34D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @34D5 revert(memory[0x00:0x00]); } // Block terminates label_34D6: // Incoming jump from 0x34D1, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @34DA stack[-2] // @34DB stack[-1] // } 34D6 5B JUMPDEST 34D7 61 PUSH2 0x34e0 34DA 82 DUP3 34DB 82 DUP3 34DC 61 PUSH2 0x282a 34DF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @34D7 stack[0] = 0x34e0 // @34DA stack[1] = stack[-2] // @34DB stack[2] = stack[-1] // } // Block ends with call to 0x282a, returns to 0x34E0 label_34E0: // Incoming return from call to 0x282A at 0x34DF // Inputs[1] { @34E1 stack[-1] } 34E0 5B JUMPDEST 34E1 15 ISZERO 34E2 61 PUSH2 0x34ea 34E5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x34ea, if !stack[-1] label_34E6: // Incoming jump from 0x34E5, if not !stack[-1] // Inputs[1] { @34E9 memory[0x00:0x00] } 34E6 60 PUSH1 0x00 34E8 80 DUP1 34E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @34E9 revert(memory[0x00:0x00]); } // Block terminates label_34EA: // Incoming jump from 0x34E5, if !stack[-1] // Inputs[5] // { // @34ED stack[-2] // @34F3 stack[-1] // @352D memory[0x00:0x40] // @3535 storage[keccak256(memory[0x00:0x40])] // @3547 stack[-3] // } 34EA 5B JUMPDEST 34EB 60 PUSH1 0x01 34ED 82 DUP3 34EE 60 PUSH1 0x00 34F0 01 ADD 34F1 60 PUSH1 0x00 34F3 83 DUP4 34F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3509 16 AND 350A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 351F 16 AND 3520 81 DUP2 3521 52 MSTORE 3522 60 PUSH1 0x20 3524 01 ADD 3525 90 SWAP1 3526 81 DUP2 3527 52 MSTORE 3528 60 PUSH1 0x20 352A 01 ADD 352B 60 PUSH1 0x00 352D 20 SHA3 352E 60 PUSH1 0x00 3530 61 PUSH2 0x0100 3533 0A EXP 3534 81 DUP2 3535 54 SLOAD 3536 81 DUP2 3537 60 PUSH1 0xff 3539 02 MUL 353A 19 NOT 353B 16 AND 353C 90 SWAP1 353D 83 DUP4 353E 15 ISZERO 353F 15 ISZERO 3540 02 MUL 3541 17 OR 3542 90 SWAP1 3543 55 SSTORE 3544 50 POP 3545 50 POP 3546 50 POP 3547 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3521 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @3527 memory[0x20:0x40] = 0x00 + stack[-2] // @3543 storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-3] label_3548: // Incoming call from 0x2E84, returns to 0x2E85 // Inputs[3] // { // @354E msg.sender // @354F stack[-2] // @3550 stack[-1] // } 3548 5B JUMPDEST 3549 60 PUSH1 0x00 354B 61 PUSH2 0x3555 354E 33 CALLER 354F 84 DUP5 3550 84 DUP5 3551 61 PUSH2 0x2e8d 3554 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @3549 stack[0] = 0x00 // @354B stack[1] = 0x3555 // @354E stack[2] = msg.sender // @354F stack[3] = stack[-2] // @3550 stack[4] = stack[-1] // } // Block ends with call to 0x2e8d, returns to 0x3555 label_3555: // Incoming return from call to 0x2E8D at 0x3554 // Inputs[3] // { // @3558 stack[-1] // @355A stack[-4] // @355B stack[-3] // } 3555 5B JUMPDEST 3556 60 PUSH1 0x01 3558 90 SWAP1 3559 50 POP 355A 92 SWAP3 355B 91 SWAP2 355C 50 POP 355D 50 POP 355E 56 *JUMP // Stack delta = -3 // Outputs[1] { @355A stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_355F: // Incoming call from 0x2BA0, returns to 0x2BA1 // Inputs[3] // { // @3560 stack[-2] // @3561 storage[stack[-2]] // @3562 stack[-1] // } 355F 5B JUMPDEST 3560 81 DUP2 3561 54 SLOAD 3562 81 DUP2 3563 83 DUP4 3564 55 SSTORE 3565 81 DUP2 3566 81 DUP2 3567 11 GT 3568 15 ISZERO 3569 61 PUSH2 0x358c 356C 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @3561 stack[0] = storage[stack[-2]] // @3564 storage[stack[-2]] = stack[-1] // } // Block ends with conditional jump to 0x358c, if !(storage[stack[-2]] > stack[-1]) label_356D: // Incoming jump from 0x356C, if not !(storage[stack[-2]] > stack[-1]) // Inputs[4] // { // @356F stack[-1] // @3570 stack[-2] // @3574 stack[-3] // @357C memory[0x00:0x20] // } 356D 60 PUSH1 0x02 356F 02 MUL 3570 81 DUP2 3571 60 PUSH1 0x02 3573 02 MUL 3574 83 DUP4 3575 60 PUSH1 0x00 3577 52 MSTORE 3578 60 PUSH1 0x20 357A 60 PUSH1 0x00 357C 20 SHA3 357D 91 SWAP2 357E 82 DUP3 357F 01 ADD 3580 91 SWAP2 3581 01 ADD 3582 61 PUSH2 0x358b 3585 91 SWAP2 3586 90 SWAP1 3587 61 PUSH2 0x3591 358A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @3577 memory[0x00:0x20] = stack[-3] // @3585 stack[-1] = 0x358b // @3586 stack[1] = keccak256(memory[0x00:0x20]) + 0x02 * stack[-2] // @3586 stack[0] = keccak256(memory[0x00:0x20]) + 0x02 * stack[-1] // } // Block ends with call to 0x3591, returns to 0x358B label_358B: // Incoming return from call to 0x3591 at 0x358A 358B 5B JUMPDEST // Stack delta = +0 // Block continues label_358C: // Incoming jump from 0x358B // Incoming jump from 0x356C, if !(storage[stack[-2]] > stack[-1]) // Inputs[1] { @3590 stack[-4] } 358C 5B JUMPDEST 358D 50 POP 358E 50 POP 358F 50 POP 3590 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_3591: // Incoming call from 0x358A, returns to 0x358B // Inputs[2] // { // @3595 stack[-2] // @3596 stack[-1] // } 3591 5B JUMPDEST 3592 61 PUSH2 0x35bd 3595 91 SWAP2 3596 90 SWAP1 3597 5B JUMPDEST 3598 80 DUP1 3599 82 DUP3 359A 11 GT 359B 15 ISZERO 359C 61 PUSH2 0x35b9 359F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @3595 stack[-2] = 0x35bd // @3596 stack[-1] = stack[-2] // @3596 stack[0] = stack[-1] // } // Block ends with conditional call to 0x35b9, returns to 0x35BD, if !(stack[-2] > stack[-1]) label_35A0: // Incoming jump from 0x359F, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x359F, if not !(stack[-2] > stack[-1]) // Inputs[1] { @35A3 stack[-1] } 35A0 60 PUSH1 0x00 35A2 80 DUP1 35A3 82 DUP3 35A4 01 ADD 35A5 60 PUSH1 0x00 35A7 90 SWAP1 35A8 55 SSTORE 35A9 60 PUSH1 0x01 35AB 82 DUP3 35AC 01 ADD 35AD 60 PUSH1 0x00 35AF 90 SWAP1 35B0 55 SSTORE 35B1 50 POP 35B2 60 PUSH1 0x02 35B4 01 ADD 35B5 61 PUSH2 0x3597 35B8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @35A8 storage[stack[-1] + 0x00] = 0x00 // @35B0 storage[stack[-1] + 0x01] = 0x00 // @35B4 stack[-1] = 0x02 + stack[-1] // } // Block ends with unconditional jump to 0x3597 label_35B9: // Incoming jump from 0x359F, if !(stack[-2] > stack[-1]) // Incoming call from 0x359F, returns to 0x35BD, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @35BB stack[-3] // @35BB stack[-2] // } 35B9 5B JUMPDEST 35BA 50 POP 35BB 90 SWAP1 35BC 56 *JUMP // Stack delta = -2 // Outputs[1] { @35BB stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_35BD: // Incoming return from call to 0x35B9 at 0x359F // Inputs[2] // { // @35BE stack[-1] // @35BE stack[-2] // } 35BD 5B JUMPDEST 35BE 90 SWAP1 35BF 56 *JUMP // Stack delta = -1 // Outputs[1] { @35BE stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] 35C0 FE *ASSERT 35C1 54 SLOAD 35C2 68 PUSH9 0x657265206973206e6f 35CC 74 PUSH21 0x20656e6f7567682062616c616e636573206f662068 35E2 6F PUSH16 0x6c6465722ea265627a7a72315820cdee 35F3 03 SUB 35F4 19 NOT 35F5 39 CODECOPY 35F6 BA BA 35F7 F1 CALL 35F8 7B PUSH28 0xf4f55d6b9bea8ea37469da7e25d2773c5a847d2d733dcc1d64736f6c 3615 63 PUSH4 0x43000511 361A 00 *STOP 361B 32 ORIGIN