Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x000f 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x000f, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000E memory[0x00:0x00] } 000C 5F PUSH0 000D 80 DUP1 000E FD *REVERT // Stack delta = +0 // Outputs[1] { @000E revert(memory[0x00:0x00]); } // Block terminates label_000F: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0013 msg.data.length } 000F 5B JUMPDEST 0010 50 POP 0011 60 PUSH1 0x04 0013 36 CALLDATASIZE 0014 10 LT 0015 61 PUSH2 0x0090 0018 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0090, if msg.data.length < 0x04 label_0019: // Incoming jump from 0x0018, if not msg.data.length < 0x04 // Inputs[1] { @001A msg.data[0x00:0x20] } 0019 5F PUSH0 001A 35 CALLDATALOAD 001B 60 PUSH1 0xe0 001D 1C SHR 001E 80 DUP1 001F 63 PUSH4 0x313ce567 0024 11 GT 0025 61 PUSH2 0x0063 0028 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001D stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0063, if 0x313ce567 > msg.data[0x00:0x20] >> 0xe0 label_0029: // Incoming jump from 0x0028, if not 0x313ce567 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0x313ce567 002F 14 EQ 0030 61 PUSH2 0x00fa 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fa, if 0x313ce567 == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0x313ce567 == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0x70a08231 003A 14 EQ 003B 61 PUSH2 0x012b 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x012b, if 0x70a08231 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0x70a08231 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0x95d89b41 0045 14 EQ 0046 61 PUSH2 0x0153 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0153, if 0x95d89b41 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0x95d89b41 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xa9059cbb 0050 14 EQ 0051 61 PUSH2 0x015b 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015b, if 0xa9059cbb == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xdd62ed3e 005B 14 EQ 005C 61 PUSH2 0x016e 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x016e, if 0xdd62ed3e == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @0062 memory[0x00:0x00] } 0060 5F PUSH0 0061 80 DUP1 0062 FD *REVERT // Stack delta = +0 // Outputs[1] { @0062 revert(memory[0x00:0x00]); } // Block terminates label_0063: // Incoming jump from 0x0028, if 0x313ce567 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0064 stack[-1] } 0063 5B JUMPDEST 0064 80 DUP1 0065 63 PUSH4 0x06fdde03 006A 14 EQ 006B 61 PUSH2 0x0094 006E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0094, if 0x06fdde03 == stack[-1] label_006F: // Incoming jump from 0x006E, if not 0x06fdde03 == stack[-1] // Inputs[1] { @006F stack[-1] } 006F 80 DUP1 0070 63 PUSH4 0x095ea7b3 0075 14 EQ 0076 61 PUSH2 0x00b2 0079 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b2, if 0x095ea7b3 == stack[-1] label_007A: // Incoming jump from 0x0079, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @007A stack[-1] } 007A 80 DUP1 007B 63 PUSH4 0x18160ddd 0080 14 EQ 0081 61 PUSH2 0x00d5 0084 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d5, if 0x18160ddd == stack[-1] label_0085: // Incoming jump from 0x0084, if not 0x18160ddd == stack[-1] // Inputs[1] { @0085 stack[-1] } 0085 80 DUP1 0086 63 PUSH4 0x23b872dd 008B 14 EQ 008C 61 PUSH2 0x00e7 008F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e7, if 0x23b872dd == stack[-1] label_0090: // Incoming jump from 0x008F, if not 0x23b872dd == stack[-1] // Incoming jump from 0x0018, if msg.data.length < 0x04 // Inputs[1] { @0093 memory[0x00:0x00] } 0090 5B JUMPDEST 0091 5F PUSH0 0092 80 DUP1 0093 FD *REVERT // Stack delta = +0 // Outputs[1] { @0093 revert(memory[0x00:0x00]); } // Block terminates label_0094: // Incoming jump from 0x006E, if 0x06fdde03 == stack[-1] 0094 5B JUMPDEST 0095 61 PUSH2 0x009c 0098 61 PUSH2 0x01a6 009B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0095 stack[0] = 0x009c } // Block ends with call to 0x01a6, returns to 0x009C label_009C: // Incoming return from call to 0x01A6 at 0x009B // Incoming return from call to 0x0272 at 0x015A // Inputs[2] // { // @009F memory[0x40:0x60] // @00A3 stack[-1] // } 009C 5B JUMPDEST 009D 60 PUSH1 0x40 009F 51 MLOAD 00A0 61 PUSH2 0x00a9 00A3 91 SWAP2 00A4 90 SWAP1 00A5 61 PUSH2 0x0575 00A8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @00A3 stack[-1] = 0x00a9 // @00A4 stack[1] = memory[0x40:0x60] // @00A4 stack[0] = stack[-1] // } // Block ends with call to 0x0575, returns to 0x00A9 label_00A9: // Incoming jump from 0x00E6 // Incoming return from call to 0x0575 at 0x00A8 // Incoming jump from 0x012A // Incoming jump from 0x00E6 // Incoming jump from 0x00D4 // Inputs[3] // { // @00AC memory[0x40:0x60] // @00AE stack[-1] // @00B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 00A9 5B JUMPDEST 00AA 60 PUSH1 0x40 00AC 51 MLOAD 00AD 80 DUP1 00AE 91 SWAP2 00AF 03 SUB 00B0 90 SWAP1 00B1 F3 *RETURN // Stack delta = -1 // Outputs[1] { @00B1 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_00B2: // Incoming jump from 0x0079, if 0x095ea7b3 == stack[-1] // Inputs[1] { @00B9 msg.data.length } 00B2 5B JUMPDEST 00B3 61 PUSH2 0x00c5 00B6 61 PUSH2 0x00c0 00B9 36 CALLDATASIZE 00BA 60 PUSH1 0x04 00BC 61 PUSH2 0x05dc 00BF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00B3 stack[0] = 0x00c5 // @00B6 stack[1] = 0x00c0 // @00B9 stack[2] = msg.data.length // @00BA stack[3] = 0x04 // } // Block ends with call to 0x05dc, returns to 0x00C0 label_00C0: // Incoming return from call to 0x05DC at 0x00BF 00C0 5B JUMPDEST 00C1 61 PUSH2 0x0236 00C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0236 label_00C5: // Incoming return from call to 0x00F5 at 0x00F4 // Inputs[2] // { // @00C8 memory[0x40:0x60] // @00C9 stack[-1] // } 00C5 5B JUMPDEST 00C6 60 PUSH1 0x40 00C8 51 MLOAD 00C9 90 SWAP1 00CA 15 ISZERO 00CB 15 ISZERO 00CC 81 DUP2 00CD 52 MSTORE 00CE 60 PUSH1 0x20 00D0 01 ADD 00D1 61 PUSH2 0x00a9 00D4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @00CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @00D0 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00a9 label_00D5: // Incoming jump from 0x0084, if 0x18160ddd == stack[-1] // Inputs[2] // { // @00D8 storage[0x02] // @00DC memory[0x40:0x60] // } 00D5 5B JUMPDEST 00D6 60 PUSH1 0x02 00D8 54 SLOAD 00D9 5B JUMPDEST 00DA 60 PUSH1 0x40 00DC 51 MLOAD 00DD 90 SWAP1 00DE 81 DUP2 00DF 52 MSTORE 00E0 60 PUSH1 0x20 00E2 01 ADD 00E3 61 PUSH2 0x00a9 00E6 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @00DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x02] // @00E2 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00a9 label_00E7: // Incoming jump from 0x008F, if 0x23b872dd == stack[-1] // Inputs[1] { @00EE msg.data.length } 00E7 5B JUMPDEST 00E8 61 PUSH2 0x00c5 00EB 61 PUSH2 0x00f5 00EE 36 CALLDATASIZE 00EF 60 PUSH1 0x04 00F1 61 PUSH2 0x0604 00F4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00E8 stack[0] = 0x00c5 // @00EB stack[1] = 0x00f5 // @00EE stack[2] = msg.data.length // @00EF stack[3] = 0x04 // } // Block ends with call to 0x0604, returns to 0x00F5 label_00F5: // Incoming return from call to 0x0604 at 0x00F4 00F5 5B JUMPDEST 00F6 61 PUSH2 0x024f 00F9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x024f label_00FA: // Incoming jump from 0x0033, if 0x313ce567 == stack[-1] // Inputs[1] { @00FD memory[0x40:0x60] } 00FA 5B JUMPDEST 00FB 60 PUSH1 0x40 00FD 51 MLOAD 00FE 60 PUSH1 0xff 0100 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000012 0121 16 AND 0122 81 DUP2 0123 52 MSTORE 0124 60 PUSH1 0x20 0126 01 ADD 0127 61 PUSH2 0x00a9 012A 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0123 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0000000000000000000000000000000000000000000000000000000000000012 & 0xff // @0126 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00a9 label_012B: // Incoming jump from 0x003E, if 0x70a08231 == stack[-1] // Inputs[1] { @0132 msg.data.length } 012B 5B JUMPDEST 012C 61 PUSH2 0x00d9 012F 61 PUSH2 0x0139 0132 36 CALLDATASIZE 0133 60 PUSH1 0x04 0135 61 PUSH2 0x063d 0138 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @012C stack[0] = 0x00d9 // @012F stack[1] = 0x0139 // @0132 stack[2] = msg.data.length // @0133 stack[3] = 0x04 // } // Block ends with call to 0x063d, returns to 0x0139 label_0139: // Incoming return from call to 0x063D at 0x0138 // Inputs[4] // { // @0142 stack[-1] // @014F memory[0x00:0x40] // @0150 storage[keccak256(memory[0x00:0x40])] // @0151 stack[-2] // } 0139 5B JUMPDEST 013A 60 PUSH1 0x01 013C 60 PUSH1 0x01 013E 60 PUSH1 0xa0 0140 1B SHL 0141 03 SUB 0142 16 AND 0143 5F PUSH0 0144 90 SWAP1 0145 81 DUP2 0146 52 MSTORE 0147 60 PUSH1 0x20 0149 81 DUP2 014A 90 SWAP1 014B 52 MSTORE 014C 60 PUSH1 0x40 014E 90 SWAP1 014F 20 SHA3 0150 54 SLOAD 0151 90 SWAP1 0152 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0146 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @014B memory[0x20:0x40] = 0x00 // @0151 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0153: // Incoming jump from 0x0049, if 0x95d89b41 == stack[-1] 0153 5B JUMPDEST 0154 61 PUSH2 0x009c 0157 61 PUSH2 0x0272 015A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0154 stack[0] = 0x009c } // Block ends with call to 0x0272, returns to 0x009C label_015B: // Incoming jump from 0x0054, if 0xa9059cbb == stack[-1] // Inputs[1] { @0162 msg.data.length } 015B 5B JUMPDEST 015C 61 PUSH2 0x00c5 015F 61 PUSH2 0x0169 0162 36 CALLDATASIZE 0163 60 PUSH1 0x04 0165 61 PUSH2 0x05dc 0168 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @015C stack[0] = 0x00c5 // @015F stack[1] = 0x0169 // @0162 stack[2] = msg.data.length // @0163 stack[3] = 0x04 // } // Block ends with call to 0x05dc, returns to 0x0169 label_0169: // Incoming return from call to 0x05DC at 0x0168 0169 5B JUMPDEST 016A 61 PUSH2 0x0281 016D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0281 label_016E: // Incoming jump from 0x005F, if 0xdd62ed3e == stack[-1] // Inputs[1] { @0175 msg.data.length } 016E 5B JUMPDEST 016F 61 PUSH2 0x00d9 0172 61 PUSH2 0x017c 0175 36 CALLDATASIZE 0176 60 PUSH1 0x04 0178 61 PUSH2 0x065d 017B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @016F stack[0] = 0x00d9 // @0172 stack[1] = 0x017c // @0175 stack[2] = msg.data.length // @0176 stack[3] = 0x04 // } // Block ends with call to 0x065d, returns to 0x017C label_017C: // Incoming return from call to 0x065D at 0x017B // Inputs[6] // { // @0185 stack[-2] // @0197 memory[0x00:0x40] // @0198 stack[-1] // @01A2 memory[0x00:0x40] // @01A3 storage[keccak256(memory[0x00:0x40])] // @01A4 stack[-3] // } 017C 5B JUMPDEST 017D 60 PUSH1 0x01 017F 60 PUSH1 0x01 0181 60 PUSH1 0xa0 0183 1B SHL 0184 03 SUB 0185 91 SWAP2 0186 82 DUP3 0187 16 AND 0188 5F PUSH0 0189 90 SWAP1 018A 81 DUP2 018B 52 MSTORE 018C 60 PUSH1 0x01 018E 60 PUSH1 0x20 0190 90 SWAP1 0191 81 DUP2 0192 52 MSTORE 0193 60 PUSH1 0x40 0195 80 DUP1 0196 83 DUP4 0197 20 SHA3 0198 93 SWAP4 0199 90 SWAP1 019A 94 SWAP5 019B 16 AND 019C 82 DUP3 019D 52 MSTORE 019E 91 SWAP2 019F 90 SWAP1 01A0 91 SWAP2 01A1 52 MSTORE 01A2 20 SHA3 01A3 54 SLOAD 01A4 90 SWAP1 01A5 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @018B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0192 memory[0x20:0x40] = 0x01 // @019D memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @01A1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @01A4 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_01A6: // Incoming call from 0x009B, returns to 0x009C // Inputs[1] { @01AC storage[0x03] } 01A6 5B JUMPDEST 01A7 60 PUSH1 0x60 01A9 60 PUSH1 0x03 01AB 80 DUP1 01AC 54 SLOAD 01AD 61 PUSH2 0x01b5 01B0 90 SWAP1 01B1 61 PUSH2 0x068e 01B4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01A7 stack[0] = 0x60 // @01A9 stack[1] = 0x03 // @01B0 stack[2] = 0x01b5 // @01B0 stack[3] = storage[0x03] // } // Block ends with call to 0x068e, returns to 0x01B5 label_01B5: // Incoming return from call to 0x068E at 0x01B4 // Incoming return from call to 0x068E at 0x0280 // Inputs[4] // { // @01B6 stack[-1] // @01C5 memory[0x40:0x60] // @01CD stack[-2] // @01D8 storage[stack[-2]] // } 01B5 5B JUMPDEST 01B6 80 DUP1 01B7 60 PUSH1 0x1f 01B9 01 ADD 01BA 60 PUSH1 0x20 01BC 80 DUP1 01BD 91 SWAP2 01BE 04 DIV 01BF 02 MUL 01C0 60 PUSH1 0x20 01C2 01 ADD 01C3 60 PUSH1 0x40 01C5 51 MLOAD 01C6 90 SWAP1 01C7 81 DUP2 01C8 01 ADD 01C9 60 PUSH1 0x40 01CB 52 MSTORE 01CC 80 DUP1 01CD 92 SWAP3 01CE 91 SWAP2 01CF 90 SWAP1 01D0 81 DUP2 01D1 81 DUP2 01D2 52 MSTORE 01D3 60 PUSH1 0x20 01D5 01 ADD 01D6 82 DUP3 01D7 80 DUP1 01D8 54 SLOAD 01D9 61 PUSH2 0x01e1 01DC 90 SWAP1 01DD 61 PUSH2 0x068e 01E0 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @01CB memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @01CD stack[-2] = memory[0x40:0x60] // @01CE stack[-1] = stack[-2] // @01CF stack[0] = stack[-1] // @01D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01D5 stack[1] = 0x20 + memory[0x40:0x60] // @01D6 stack[2] = stack[-2] // @01DC stack[4] = storage[stack[-2]] // @01DC stack[3] = 0x01e1 // } // Block ends with call to 0x068e, returns to 0x01E1 label_01E1: // Incoming return from call to 0x068E at 0x01E0 // Inputs[1] { @01E2 stack[-1] } 01E1 5B JUMPDEST 01E2 80 DUP1 01E3 15 ISZERO 01E4 61 PUSH2 0x022c 01E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022c, if !stack[-1] label_01E8: // Incoming jump from 0x01E7, if not !stack[-1] // Inputs[1] { @01E8 stack[-1] } 01E8 80 DUP1 01E9 60 PUSH1 0x1f 01EB 10 LT 01EC 61 PUSH2 0x0203 01EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0203, if 0x1f < stack[-1] label_01F0: // Incoming jump from 0x01EF, if not 0x1f < stack[-1] // Inputs[4] // { // @01F4 stack[-2] // @01F5 storage[stack[-2]] // @01F8 stack[-3] // @01FA stack[-1] // } 01F0 61 PUSH2 0x0100 01F3 80 DUP1 01F4 83 DUP4 01F5 54 SLOAD 01F6 04 DIV 01F7 02 MUL 01F8 83 DUP4 01F9 52 MSTORE 01FA 91 SWAP2 01FB 60 PUSH1 0x20 01FD 01 ADD 01FE 91 SWAP2 01FF 61 PUSH2 0x022c 0202 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @01F9 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @01FE stack[-1] = stack[-1] // @01FE stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x022c label_0203: // Incoming jump from 0x01EF, if 0x1f < stack[-1] // Inputs[5] // { // @0204 stack[-3] // @0205 stack[-1] // @0207 stack[-2] // @020D memory[0x00:0x20] // @0211 storage[keccak256(memory[0x00:0x20])] // } 0203 5B JUMPDEST 0204 82 DUP3 0205 01 ADD 0206 91 SWAP2 0207 90 SWAP1 0208 5F PUSH0 0209 52 MSTORE 020A 60 PUSH1 0x20 020C 5F PUSH0 020D 20 SHA3 020E 90 SWAP1 020F 5B JUMPDEST 0210 81 DUP2 0211 54 SLOAD 0212 81 DUP2 0213 52 MSTORE 0214 90 SWAP1 0215 60 PUSH1 0x01 0217 01 ADD 0218 90 SWAP1 0219 60 PUSH1 0x20 021B 01 ADD 021C 80 DUP1 021D 83 DUP4 021E 11 GT 021F 61 PUSH2 0x020f 0222 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0206 stack[-3] = stack[-3] + stack[-1] // @0209 memory[0x00:0x20] = stack[-2] // @0213 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0218 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @021B stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x020f, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0223: // Incoming jump from 0x0222, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0222, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0223 stack[-3] // @0224 stack[-1] // } 0223 82 DUP3 0224 90 SWAP1 0225 03 SUB 0226 60 PUSH1 0x1f 0228 16 AND 0229 82 DUP3 022A 01 ADD 022B 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @022B stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @022B stack[-1] = stack[-3] // } // Block continues label_022C: // Incoming jump from 0x01E7, if !stack[-1] // Incoming jump from 0x022B // Incoming jump from 0x0202 // Inputs[3] // { // @0232 stack[-7] // @0232 stack[-6] // @0234 stack[-8] // } 022C 5B JUMPDEST 022D 50 POP 022E 50 POP 022F 50 POP 0230 50 POP 0231 50 POP 0232 90 SWAP1 0233 50 POP 0234 90 SWAP1 0235 56 *JUMP // Stack delta = -7 // Outputs[1] { @0234 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0236: // Incoming jump from 0x00C4 // Inputs[3] // { // @0238 msg.sender // @023D stack[-2] // @023E stack[-1] // } 0236 5B JUMPDEST 0237 5F PUSH0 0238 33 CALLER 0239 61 PUSH2 0x0243 023C 81 DUP2 023D 85 DUP6 023E 85 DUP6 023F 61 PUSH2 0x028e 0242 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0237 stack[0] = 0x00 // @0238 stack[1] = msg.sender // @0239 stack[2] = 0x0243 // @023C stack[3] = msg.sender // @023D stack[4] = stack[-2] // @023E stack[5] = stack[-1] // } // Block ends with call to 0x028e, returns to 0x0243 label_0243: // Incoming return from call to 0x028E at 0x0242 // Incoming return from call to 0x0320 at 0x028D // Inputs[1] { @0246 stack[-2] } 0243 5B JUMPDEST 0244 60 PUSH1 0x01 0246 91 SWAP2 0247 50 POP 0248 50 POP // Stack delta = -1 // Outputs[1] { @0246 stack[-2] = 0x01 } // Block continues label_0249: // Incoming jump from 0x06D1, if !(stack[-1] > stack[-2] + stack[-1]) // Incoming jump from 0x0248 // Inputs[3] // { // @024A stack[-4] // @024A stack[-1] // @024B stack[-3] // } 0249 5B JUMPDEST 024A 92 SWAP3 024B 91 SWAP2 024C 50 POP 024D 50 POP 024E 56 *JUMP // Stack delta = -3 // Outputs[1] { @024A stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_024F: // Incoming jump from 0x00F9 // Inputs[3] // { // @0251 msg.sender // @0255 stack[-3] // @0257 stack[-1] // } 024F 5B JUMPDEST 0250 5F PUSH0 0251 33 CALLER 0252 61 PUSH2 0x025c 0255 85 DUP6 0256 82 DUP3 0257 85 DUP6 0258 61 PUSH2 0x02a0 025B 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0250 stack[0] = 0x00 // @0251 stack[1] = msg.sender // @0252 stack[2] = 0x025c // @0255 stack[3] = stack[-3] // @0256 stack[4] = msg.sender // @0257 stack[5] = stack[-1] // } // Block ends with call to 0x02a0, returns to 0x025C label_025C: // Incoming return from call to 0x02A0 at 0x025B // Inputs[3] // { // @0260 stack[-5] // @0261 stack[-4] // @0262 stack[-3] // } 025C 5B JUMPDEST 025D 61 PUSH2 0x0267 0260 85 DUP6 0261 85 DUP6 0262 85 DUP6 0263 61 PUSH2 0x0320 0266 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @025D stack[0] = 0x0267 // @0260 stack[1] = stack[-5] // @0261 stack[2] = stack[-4] // @0262 stack[3] = stack[-3] // } // Block ends with call to 0x0320, returns to 0x0267 label_0267: // Incoming return from call to 0x0320 at 0x0266 // Inputs[2] // { // @026B stack[-6] // @026C stack[-5] // } 0267 5B JUMPDEST 0268 50 POP 0269 60 PUSH1 0x01 026B 94 SWAP5 026C 93 SWAP4 026D 50 POP 026E 50 POP 026F 50 POP 0270 50 POP 0271 56 *JUMP // Stack delta = -5 // Outputs[1] { @026B stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_0272: // Incoming call from 0x015A, returns to 0x009C // Inputs[1] { @0278 storage[0x04] } 0272 5B JUMPDEST 0273 60 PUSH1 0x60 0275 60 PUSH1 0x04 0277 80 DUP1 0278 54 SLOAD 0279 61 PUSH2 0x01b5 027C 90 SWAP1 027D 61 PUSH2 0x068e 0280 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0273 stack[0] = 0x60 // @0275 stack[1] = 0x04 // @027C stack[2] = 0x01b5 // @027C stack[3] = storage[0x04] // } // Block ends with call to 0x068e, returns to 0x01B5 label_0281: // Incoming jump from 0x016D // Inputs[3] // { // @0283 msg.sender // @0288 stack[-2] // @0289 stack[-1] // } 0281 5B JUMPDEST 0282 5F PUSH0 0283 33 CALLER 0284 61 PUSH2 0x0243 0287 81 DUP2 0288 85 DUP6 0289 85 DUP6 028A 61 PUSH2 0x0320 028D 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0282 stack[0] = 0x00 // @0283 stack[1] = msg.sender // @0284 stack[2] = 0x0243 // @0287 stack[3] = msg.sender // @0288 stack[4] = stack[-2] // @0289 stack[5] = stack[-1] // } // Block ends with call to 0x0320, returns to 0x0243 label_028E: // Incoming call from 0x0242, returns to 0x0243 // Inputs[3] // { // @0292 stack[-3] // @0293 stack[-2] // @0294 stack[-1] // } 028E 5B JUMPDEST 028F 61 PUSH2 0x029b 0292 83 DUP4 0293 83 DUP4 0294 83 DUP4 0295 60 PUSH1 0x01 0297 61 PUSH2 0x037d 029A 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @028F stack[0] = 0x029b // @0292 stack[1] = stack[-3] // @0293 stack[2] = stack[-2] // @0294 stack[3] = stack[-1] // @0295 stack[4] = 0x01 // } // Block ends with call to 0x037d, returns to 0x029B label_029B: // Incoming return from call to 0x037D at 0x029A // Incoming return from call to 0x044F at 0x037C // Inputs[1] { @029F stack[-4] } 029B 5B JUMPDEST 029C 50 POP 029D 50 POP 029E 50 POP 029F 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_02A0: // Incoming call from 0x025B, returns to 0x025C // Inputs[5] // { // @02A9 stack[-3] // @02BB memory[0x00:0x40] // @02BD stack[-2] // @02C4 memory[0x00:0x40] // @02C5 storage[keccak256(memory[0x00:0x40])] // } 02A0 5B JUMPDEST 02A1 60 PUSH1 0x01 02A3 60 PUSH1 0x01 02A5 60 PUSH1 0xa0 02A7 1B SHL 02A8 03 SUB 02A9 83 DUP4 02AA 81 DUP2 02AB 16 AND 02AC 5F PUSH0 02AD 90 SWAP1 02AE 81 DUP2 02AF 52 MSTORE 02B0 60 PUSH1 0x01 02B2 60 PUSH1 0x20 02B4 90 SWAP1 02B5 81 DUP2 02B6 52 MSTORE 02B7 60 PUSH1 0x40 02B9 80 DUP1 02BA 83 DUP4 02BB 20 SHA3 02BC 93 SWAP4 02BD 86 DUP7 02BE 16 AND 02BF 83 DUP4 02C0 52 MSTORE 02C1 92 SWAP3 02C2 90 SWAP1 02C3 52 MSTORE 02C4 20 SHA3 02C5 54 SLOAD 02C6 5F PUSH0 02C7 19 NOT 02C8 81 DUP2 02C9 14 EQ 02CA 61 PUSH2 0x031a 02CD 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @02AF memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @02B6 memory[0x20:0x40] = 0x01 // @02C0 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @02C3 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @02C5 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x031a, if storage[keccak256(memory[0x00:0x40])] == ~0x00 label_02CE: // Incoming jump from 0x02CD, if not storage[keccak256(memory[0x00:0x40])] == ~0x00 // Inputs[2] // { // @02CE stack[-2] // @02CF stack[-1] // } 02CE 81 DUP2 02CF 81 DUP2 02D0 10 LT 02D1 15 ISZERO 02D2 61 PUSH2 0x030c 02D5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030c, if !(stack[-1] < stack[-2]) label_02D6: // Incoming jump from 0x02D5, if not !(stack[-1] < stack[-2]) // Inputs[4] // { // @02D8 memory[0x40:0x60] // @02EB stack[-3] // @02F6 stack[-1] // @02FD stack[-2] // } 02D6 60 PUSH1 0x40 02D8 51 MLOAD 02D9 63 PUSH4 0x7dc7a0d9 02DE 60 PUSH1 0xe1 02E0 1B SHL 02E1 81 DUP2 02E2 52 MSTORE 02E3 60 PUSH1 0x01 02E5 60 PUSH1 0x01 02E7 60 PUSH1 0xa0 02E9 1B SHL 02EA 03 SUB 02EB 84 DUP5 02EC 16 AND 02ED 60 PUSH1 0x04 02EF 82 DUP3 02F0 01 ADD 02F1 52 MSTORE 02F2 60 PUSH1 0x24 02F4 81 DUP2 02F5 01 ADD 02F6 82 DUP3 02F7 90 SWAP1 02F8 52 MSTORE 02F9 60 PUSH1 0x44 02FB 81 DUP2 02FC 01 ADD 02FD 83 DUP4 02FE 90 SWAP1 02FF 52 MSTORE 0300 60 PUSH1 0x64 0302 01 ADD // Stack delta = +1 // Outputs[5] // { // @02E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x7dc7a0d9 << 0xe1 // @02F1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @02F8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] // @02FF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-2] // @0302 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_0303: // Incoming jump from 0x0371 // Incoming jump from 0x04CA // Incoming jump from 0x03CE // Incoming jump from 0x03A5 // Incoming jump from 0x0302 // Incoming jump from 0x0348 // Inputs[3] // { // @0306 memory[0x40:0x60] // @0308 stack[-1] // @030B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0303 5B JUMPDEST 0304 60 PUSH1 0x40 0306 51 MLOAD 0307 80 DUP1 0308 91 SWAP2 0309 03 SUB 030A 90 SWAP1 030B FD *REVERT // Stack delta = -1 // Outputs[1] { @030B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_030C: // Incoming jump from 0x02D5, if !(stack[-1] < stack[-2]) // Inputs[4] // { // @0310 stack[-4] // @0311 stack[-3] // @0312 stack[-2] // @0313 stack[-1] // } 030C 5B JUMPDEST 030D 61 PUSH2 0x031a 0310 84 DUP5 0311 84 DUP5 0312 84 DUP5 0313 84 DUP5 0314 03 SUB 0315 5F PUSH0 0316 61 PUSH2 0x037d 0319 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @030D stack[0] = 0x031a // @0310 stack[1] = stack[-4] // @0311 stack[2] = stack[-3] // @0314 stack[3] = stack[-1] - stack[-2] // @0315 stack[4] = 0x00 // } // Block ends with call to 0x037d, returns to 0x031A label_031A: // Incoming jump from 0x02CD, if storage[keccak256(memory[0x00:0x40])] == ~0x00 // Incoming return from call to 0x037D at 0x0319 // Incoming jump from 0x03FC, if !stack[-1] // Inputs[1] { @031F stack[-5] } 031A 5B JUMPDEST 031B 50 POP 031C 50 POP 031D 50 POP 031E 50 POP 031F 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0320: // Incoming call from 0x0266, returns to 0x0267 // Incoming call from 0x028D, returns to 0x0243 // Inputs[1] { @0329 stack[-3] } 0320 5B JUMPDEST 0321 60 PUSH1 0x01 0323 60 PUSH1 0x01 0325 60 PUSH1 0xa0 0327 1B SHL 0328 03 SUB 0329 83 DUP4 032A 16 AND 032B 61 PUSH2 0x0349 032E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0349, if stack[-3] & (0x01 << 0xa0) - 0x01 label_032F: // Incoming jump from 0x032E, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0331 memory[0x40:0x60] } 032F 60 PUSH1 0x40 0331 51 MLOAD 0332 63 PUSH4 0x4b637e8f 0337 60 PUSH1 0xe1 0339 1B SHL 033A 81 DUP2 033B 52 MSTORE 033C 5F PUSH0 033D 60 PUSH1 0x04 033F 82 DUP3 0340 01 ADD 0341 52 MSTORE 0342 60 PUSH1 0x24 0344 01 ADD 0345 61 PUSH2 0x0303 0348 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @033B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x4b637e8f << 0xe1 // @0341 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x00 // @0344 stack[0] = 0x24 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0303 label_0349: // Incoming jump from 0x032E, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0352 stack[-2] } 0349 5B JUMPDEST 034A 60 PUSH1 0x01 034C 60 PUSH1 0x01 034E 60 PUSH1 0xa0 0350 1B SHL 0351 03 SUB 0352 82 DUP3 0353 16 AND 0354 61 PUSH2 0x0372 0357 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0372, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0358: // Incoming jump from 0x0357, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @035A memory[0x40:0x60] } 0358 60 PUSH1 0x40 035A 51 MLOAD 035B 63 PUSH4 0xec442f05 0360 60 PUSH1 0xe0 0362 1B SHL 0363 81 DUP2 0364 52 MSTORE 0365 5F PUSH0 0366 60 PUSH1 0x04 0368 82 DUP3 0369 01 ADD 036A 52 MSTORE 036B 60 PUSH1 0x24 036D 01 ADD 036E 61 PUSH2 0x0303 0371 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0364 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xec442f05 << 0xe0 // @036A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x00 // @036D stack[0] = 0x24 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0303 label_0372: // Incoming jump from 0x0357, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0376 stack[-3] // @0377 stack[-2] // @0378 stack[-1] // } 0372 5B JUMPDEST 0373 61 PUSH2 0x029b 0376 83 DUP4 0377 83 DUP4 0378 83 DUP4 0379 61 PUSH2 0x044f 037C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0373 stack[0] = 0x029b // @0376 stack[1] = stack[-3] // @0377 stack[2] = stack[-2] // @0378 stack[3] = stack[-1] // } // Block ends with call to 0x044f, returns to 0x029B label_037D: // Incoming call from 0x0319, returns to 0x031A // Incoming call from 0x029A, returns to 0x029B // Inputs[1] { @0386 stack[-4] } 037D 5B JUMPDEST 037E 60 PUSH1 0x01 0380 60 PUSH1 0x01 0382 60 PUSH1 0xa0 0384 1B SHL 0385 03 SUB 0386 84 DUP5 0387 16 AND 0388 61 PUSH2 0x03a6 038B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a6, if stack[-4] & (0x01 << 0xa0) - 0x01 label_038C: // Incoming jump from 0x038B, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @038E memory[0x40:0x60] } 038C 60 PUSH1 0x40 038E 51 MLOAD 038F 63 PUSH4 0xe602df05 0394 60 PUSH1 0xe0 0396 1B SHL 0397 81 DUP2 0398 52 MSTORE 0399 5F PUSH0 039A 60 PUSH1 0x04 039C 82 DUP3 039D 01 ADD 039E 52 MSTORE 039F 60 PUSH1 0x24 03A1 01 ADD 03A2 61 PUSH2 0x0303 03A5 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0398 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe602df05 << 0xe0 // @039E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x00 // @03A1 stack[0] = 0x24 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0303 label_03A6: // Incoming jump from 0x038B, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @03AF stack[-3] } 03A6 5B JUMPDEST 03A7 60 PUSH1 0x01 03A9 60 PUSH1 0x01 03AB 60 PUSH1 0xa0 03AD 1B SHL 03AE 03 SUB 03AF 83 DUP4 03B0 16 AND 03B1 61 PUSH2 0x03cf 03B4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cf, if stack[-3] & (0x01 << 0xa0) - 0x01 label_03B5: // Incoming jump from 0x03B4, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @03B7 memory[0x40:0x60] } 03B5 60 PUSH1 0x40 03B7 51 MLOAD 03B8 63 PUSH4 0x4a1406b1 03BD 60 PUSH1 0xe1 03BF 1B SHL 03C0 81 DUP2 03C1 52 MSTORE 03C2 5F PUSH0 03C3 60 PUSH1 0x04 03C5 82 DUP3 03C6 01 ADD 03C7 52 MSTORE 03C8 60 PUSH1 0x24 03CA 01 ADD 03CB 61 PUSH2 0x0303 03CE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @03C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x4a1406b1 << 0xe1 // @03C7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x00 // @03CA stack[0] = 0x24 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0303 label_03CF: // Incoming jump from 0x03B4, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @03D9 stack[-4] // @03EA memory[0x00:0x40] // @03EC stack[-3] // @03F3 memory[0x00:0x40] // @03F4 stack[-2] // @03F7 stack[-1] // } 03CF 5B JUMPDEST 03D0 60 PUSH1 0x01 03D2 60 PUSH1 0x01 03D4 60 PUSH1 0xa0 03D6 1B SHL 03D7 03 SUB 03D8 80 DUP1 03D9 85 DUP6 03DA 16 AND 03DB 5F PUSH0 03DC 90 SWAP1 03DD 81 DUP2 03DE 52 MSTORE 03DF 60 PUSH1 0x01 03E1 60 PUSH1 0x20 03E3 90 SWAP1 03E4 81 DUP2 03E5 52 MSTORE 03E6 60 PUSH1 0x40 03E8 80 DUP1 03E9 83 DUP4 03EA 20 SHA3 03EB 93 SWAP4 03EC 87 DUP8 03ED 16 AND 03EE 83 DUP4 03EF 52 MSTORE 03F0 92 SWAP3 03F1 90 SWAP1 03F2 52 MSTORE 03F3 20 SHA3 03F4 82 DUP3 03F5 90 SWAP1 03F6 55 SSTORE 03F7 80 DUP1 03F8 15 ISZERO 03F9 61 PUSH2 0x031a 03FC 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @03DE memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @03E5 memory[0x20:0x40] = 0x01 // @03EF memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @03F2 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @03F6 storage[keccak256(memory[0x00:0x40])] = stack[-2] // } // Block ends with conditional jump to 0x031a, if !stack[-1] label_03FD: // Incoming jump from 0x03FC, if not !stack[-1] // Inputs[4] // { // @03FD stack[-3] // @0407 stack[-4] // @0432 stack[-2] // @0435 memory[0x40:0x60] // } 03FD 82 DUP3 03FE 60 PUSH1 0x01 0400 60 PUSH1 0x01 0402 60 PUSH1 0xa0 0404 1B SHL 0405 03 SUB 0406 16 AND 0407 84 DUP5 0408 60 PUSH1 0x01 040A 60 PUSH1 0x01 040C 60 PUSH1 0xa0 040E 1B SHL 040F 03 SUB 0410 16 AND 0411 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0432 84 DUP5 0433 60 PUSH1 0x40 0435 51 MLOAD 0436 61 PUSH2 0x0441 0439 91 SWAP2 043A 81 DUP2 043B 52 MSTORE 043C 60 PUSH1 0x20 043E 01 ADD 043F 90 SWAP1 0440 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0406 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0410 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-4] // @0411 stack[2] = 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 // @043B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @043F stack[3] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0441 label_0441: // Incoming jump from 0x0440 // Inputs[7] // { // @0444 memory[0x40:0x60] // @0446 stack[-1] // @0449 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0449 stack[-3] // @0449 stack[-4] // @0449 stack[-2] // @044E stack[-9] // } 0441 5B JUMPDEST 0442 60 PUSH1 0x40 0444 51 MLOAD 0445 80 DUP1 0446 91 SWAP2 0447 03 SUB 0448 90 SWAP1 0449 A3 LOG3 044A 50 POP 044B 50 POP 044C 50 POP 044D 50 POP 044E 56 *JUMP // Stack delta = -9 // Outputs[1] { @0449 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-9] label_044F: // Incoming call from 0x037C, returns to 0x029B // Inputs[1] { @0458 stack[-3] } 044F 5B JUMPDEST 0450 60 PUSH1 0x01 0452 60 PUSH1 0x01 0454 60 PUSH1 0xa0 0456 1B SHL 0457 03 SUB 0458 83 DUP4 0459 16 AND 045A 61 PUSH2 0x0479 045D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0479, if stack[-3] & (0x01 << 0xa0) - 0x01 label_045E: // Incoming jump from 0x045D, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @045E stack[-1] // @0464 storage[0x02] // } 045E 80 DUP1 045F 60 PUSH1 0x02 0461 5F PUSH0 0462 82 DUP3 0463 82 DUP3 0464 54 SLOAD 0465 61 PUSH2 0x046e 0468 91 SWAP2 0469 90 SWAP1 046A 61 PUSH2 0x06c6 046D 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @045E stack[0] = stack[-1] // @045F stack[1] = 0x02 // @0461 stack[2] = 0x00 // @0468 stack[3] = 0x046e // @0469 stack[4] = stack[-1] // @0469 stack[5] = storage[0x02] // } // Block ends with call to 0x06c6, returns to 0x046E label_046E: // Incoming return from call to 0x06C6 at 0x046D // Inputs[4] // { // @046F stack[-2] // @046F stack[-1] // @0470 stack[-3] // @0476 stack[-4] // } 046E 5B JUMPDEST 046F 90 SWAP1 0470 91 SWAP2 0471 55 SSTORE 0472 50 POP 0473 61 PUSH2 0x04e9 0476 90 SWAP1 0477 50 POP 0478 56 *JUMP // Stack delta = -4 // Outputs[1] { @0471 storage[stack[-3]] = stack[-1] } // Block ends with unconditional jump to 0x04e9 label_0479: // Incoming jump from 0x045D, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0482 stack[-3] // @0490 memory[0x00:0x40] // @0491 storage[keccak256(memory[0x00:0x40])] // @0492 stack[-1] // } 0479 5B JUMPDEST 047A 60 PUSH1 0x01 047C 60 PUSH1 0x01 047E 60 PUSH1 0xa0 0480 1B SHL 0481 03 SUB 0482 83 DUP4 0483 16 AND 0484 5F PUSH0 0485 90 SWAP1 0486 81 DUP2 0487 52 MSTORE 0488 60 PUSH1 0x20 048A 81 DUP2 048B 90 SWAP1 048C 52 MSTORE 048D 60 PUSH1 0x40 048F 90 SWAP1 0490 20 SHA3 0491 54 SLOAD 0492 81 DUP2 0493 81 DUP2 0494 10 LT 0495 15 ISZERO 0496 61 PUSH2 0x04cb 0499 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0487 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @048C memory[0x20:0x40] = 0x00 // @0491 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x04cb, if !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) label_049A: // Incoming jump from 0x0499, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[4] // { // @049C memory[0x40:0x60] // @04AF stack[-4] // @04BA stack[-1] // @04C1 stack[-2] // } 049A 60 PUSH1 0x40 049C 51 MLOAD 049D 63 PUSH4 0x391434e3 04A2 60 PUSH1 0xe2 04A4 1B SHL 04A5 81 DUP2 04A6 52 MSTORE 04A7 60 PUSH1 0x01 04A9 60 PUSH1 0x01 04AB 60 PUSH1 0xa0 04AD 1B SHL 04AE 03 SUB 04AF 85 DUP6 04B0 16 AND 04B1 60 PUSH1 0x04 04B3 82 DUP3 04B4 01 ADD 04B5 52 MSTORE 04B6 60 PUSH1 0x24 04B8 81 DUP2 04B9 01 ADD 04BA 82 DUP3 04BB 90 SWAP1 04BC 52 MSTORE 04BD 60 PUSH1 0x44 04BF 81 DUP2 04C0 01 ADD 04C1 83 DUP4 04C2 90 SWAP1 04C3 52 MSTORE 04C4 60 PUSH1 0x64 04C6 01 ADD 04C7 61 PUSH2 0x0303 04CA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @04A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x391434e3 << 0xe2 // @04B5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @04BC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] // @04C3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-2] // @04C6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0303 label_04CB: // Incoming jump from 0x0499, if !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[5] // { // @04D4 stack[-4] // @04E2 memory[0x00:0x40] // @04E3 stack[-1] // @04E4 stack[-2] // @04F2 stack[-3] // } 04CB 5B JUMPDEST 04CC 60 PUSH1 0x01 04CE 60 PUSH1 0x01 04D0 60 PUSH1 0xa0 04D2 1B SHL 04D3 03 SUB 04D4 84 DUP5 04D5 16 AND 04D6 5F PUSH0 04D7 90 SWAP1 04D8 81 DUP2 04D9 52 MSTORE 04DA 60 PUSH1 0x20 04DC 81 DUP2 04DD 90 SWAP1 04DE 52 MSTORE 04DF 60 PUSH1 0x40 04E1 90 SWAP1 04E2 20 SHA3 04E3 90 SWAP1 04E4 82 DUP3 04E5 90 SWAP1 04E6 03 SUB 04E7 90 SWAP1 04E8 55 SSTORE 04E9 5B JUMPDEST 04EA 60 PUSH1 0x01 04EC 60 PUSH1 0x01 04EE 60 PUSH1 0xa0 04F0 1B SHL 04F1 03 SUB 04F2 82 DUP3 04F3 16 AND 04F4 61 PUSH2 0x0505 04F7 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @04D9 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @04DE memory[0x20:0x40] = 0x00 // @04E8 storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-2] // } // Block ends with conditional jump to 0x0505, if stack[-3] & (0x01 << 0xa0) - 0x01 label_04F8: // Incoming jump from 0x04F7, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x04F7, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @04FB storage[0x02] // @04FC stack[-1] // } 04F8 60 PUSH1 0x02 04FA 80 DUP1 04FB 54 SLOAD 04FC 82 DUP3 04FD 90 SWAP1 04FE 03 SUB 04FF 90 SWAP1 0500 55 SSTORE 0501 61 PUSH2 0x0523 0504 56 *JUMP // Stack delta = +0 // Outputs[1] { @0500 storage[0x02] = storage[0x02] - stack[-1] } // Block ends with unconditional jump to 0x0523 label_0505: // Incoming jump from 0x04F7, if stack[-2] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x04F7, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @050E stack[-2] // @051C memory[0x00:0x40] // @051E storage[keccak256(memory[0x00:0x40])] // @051F stack[-1] // @052E stack[-3] // @055C memory[0x40:0x60] // } 0505 5B JUMPDEST 0506 60 PUSH1 0x01 0508 60 PUSH1 0x01 050A 60 PUSH1 0xa0 050C 1B SHL 050D 03 SUB 050E 82 DUP3 050F 16 AND 0510 5F PUSH0 0511 90 SWAP1 0512 81 DUP2 0513 52 MSTORE 0514 60 PUSH1 0x20 0516 81 DUP2 0517 90 SWAP1 0518 52 MSTORE 0519 60 PUSH1 0x40 051B 90 SWAP1 051C 20 SHA3 051D 80 DUP1 051E 54 SLOAD 051F 82 DUP3 0520 01 ADD 0521 90 SWAP1 0522 55 SSTORE 0523 5B JUMPDEST 0524 81 DUP2 0525 60 PUSH1 0x01 0527 60 PUSH1 0x01 0529 60 PUSH1 0xa0 052B 1B SHL 052C 03 SUB 052D 16 AND 052E 83 DUP4 052F 60 PUSH1 0x01 0531 60 PUSH1 0x01 0533 60 PUSH1 0xa0 0535 1B SHL 0536 03 SUB 0537 16 AND 0538 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0559 83 DUP4 055A 60 PUSH1 0x40 055C 51 MLOAD 055D 61 PUSH2 0x0568 0560 91 SWAP2 0561 81 DUP2 0562 52 MSTORE 0563 60 PUSH1 0x20 0565 01 ADD 0566 90 SWAP1 0567 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @0513 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0518 memory[0x20:0x40] = 0x00 // @0522 storage[keccak256(memory[0x00:0x40])] = stack[-1] + storage[keccak256(memory[0x00:0x40])] // @052D stack[0] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0537 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0538 stack[2] = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef // @0562 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0566 stack[3] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0568 label_0568: // Incoming jump from 0x0567 // Incoming jump from 0x0567 // Inputs[7] // { // @056B memory[0x40:0x60] // @056D stack[-1] // @0570 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0570 stack[-4] // @0570 stack[-3] // @0570 stack[-2] // @0574 stack[-8] // } 0568 5B JUMPDEST 0569 60 PUSH1 0x40 056B 51 MLOAD 056C 80 DUP1 056D 91 SWAP2 056E 03 SUB 056F 90 SWAP1 0570 A3 LOG3 0571 50 POP 0572 50 POP 0573 50 POP 0574 56 *JUMP // Stack delta = -8 // Outputs[1] { @0570 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-8] label_0575: // Incoming call from 0x00A8, returns to 0x00A9 // Inputs[3] // { // @057A stack[-1] // @057C stack[-2] // @057D memory[stack[-2]:stack[-2] + 0x20] // } 0575 5B JUMPDEST 0576 5F PUSH0 0577 60 PUSH1 0x20 0579 80 DUP1 057A 83 DUP4 057B 52 MSTORE 057C 83 DUP4 057D 51 MLOAD 057E 80 DUP1 057F 60 PUSH1 0x20 0581 85 DUP6 0582 01 ADD 0583 52 MSTORE 0584 5F PUSH0 0585 5B JUMPDEST 0586 81 DUP2 0587 81 DUP2 0588 10 LT 0589 15 ISZERO 058A 61 PUSH2 0x05a1 058D 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @0576 stack[0] = 0x00 // @0577 stack[1] = 0x20 // @057B memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @057D stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @0583 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0584 stack[3] = 0x00 // } // Block ends with conditional jump to 0x05a1, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_058E: // Incoming jump from 0x058D, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x058D, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[5] // { // @058E stack[-6] // @058F stack[-1] // @0591 stack[-3] // @0593 memory[stack[-3] + stack[-1] + stack[-6]:stack[-3] + stack[-1] + stack[-6] + 0x20] // @0594 stack[-5] // } 058E 85 DUP6 058F 81 DUP2 0590 01 ADD 0591 83 DUP4 0592 01 ADD 0593 51 MLOAD 0594 85 DUP6 0595 82 DUP3 0596 01 ADD 0597 60 PUSH1 0x40 0599 01 ADD 059A 52 MSTORE 059B 82 DUP3 059C 01 ADD 059D 61 PUSH2 0x0585 05A0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @059A memory[0x40 + stack[-1] + stack[-5]:0x40 + stack[-1] + stack[-5] + 0x20] = memory[stack[-3] + stack[-1] + stack[-6]:stack[-3] + stack[-1] + stack[-6] + 0x20] // @059C stack[-1] = stack[-3] + stack[-1] // } // Block ends with unconditional jump to 0x0585 label_05A1: // Incoming jump from 0x058D, if !(stack[-1] < stack[-2]) // Incoming jump from 0x058D, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[5] // { // @05A6 stack[-2] // @05A7 stack[-5] // @05B8 stack[-4] // @05BC stack[-7] // @05BD stack[-6] // } 05A1 5B JUMPDEST 05A2 50 POP 05A3 5F PUSH0 05A4 60 PUSH1 0x40 05A6 82 DUP3 05A7 86 DUP7 05A8 01 ADD 05A9 01 ADD 05AA 52 MSTORE 05AB 60 PUSH1 0x40 05AD 60 PUSH1 0x1f 05AF 19 NOT 05B0 60 PUSH1 0x1f 05B2 83 DUP4 05B3 01 ADD 05B4 16 AND 05B5 85 DUP6 05B6 01 ADD 05B7 01 ADD 05B8 92 SWAP3 05B9 50 POP 05BA 50 POP 05BB 50 POP 05BC 92 SWAP3 05BD 91 SWAP2 05BE 50 POP 05BF 50 POP 05C0 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @05AA memory[stack[-5] + stack[-2] + 0x40:stack[-5] + stack[-2] + 0x40 + 0x20] = 0x00 // @05BC stack[-7] = stack[-5] + (stack[-2] + 0x1f & ~0x1f) + 0x40 // } // Block ends with unconditional jump to stack[-7] label_05C1: // Incoming call from 0x0676, returns to 0x0677 // Incoming call from 0x061E, returns to 0x061F // Incoming call from 0x0684, returns to 0x0685 // Incoming call from 0x05F5, returns to 0x05F6 // Incoming call from 0x062C, returns to 0x062D // Incoming call from 0x0655, returns to 0x0656 // Inputs[2] // { // @05C2 stack[-1] // @05C3 msg.data[stack[-1]:stack[-1] + 0x20] // } 05C1 5B JUMPDEST 05C2 80 DUP1 05C3 35 CALLDATALOAD 05C4 60 PUSH1 0x01 05C6 60 PUSH1 0x01 05C8 60 PUSH1 0xa0 05CA 1B SHL 05CB 03 SUB 05CC 81 DUP2 05CD 16 AND 05CE 81 DUP2 05CF 14 EQ 05D0 61 PUSH2 0x05d7 05D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C3 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x05d7, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_05D4: // Incoming jump from 0x05D3, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @05D6 memory[0x00:0x00] } 05D4 5F PUSH0 05D5 80 DUP1 05D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D6 revert(memory[0x00:0x00]); } // Block terminates label_05D7: // Incoming jump from 0x05D3, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @05D8 stack[-1] // @05D8 stack[-3] // @05D9 stack[-2] // } 05D7 5B JUMPDEST 05D8 91 SWAP2 05D9 90 SWAP1 05DA 50 POP 05DB 56 *JUMP // Stack delta = -2 // Outputs[1] { @05D8 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_05DC: // Incoming call from 0x0168, returns to 0x0169 // Incoming call from 0x00BF, returns to 0x00C0 // Inputs[2] // { // @05E1 stack[-1] // @05E2 stack[-2] // } 05DC 5B JUMPDEST 05DD 5F PUSH0 05DE 80 DUP1 05DF 60 PUSH1 0x40 05E1 83 DUP4 05E2 85 DUP6 05E3 03 SUB 05E4 12 SLT 05E5 15 ISZERO 05E6 61 PUSH2 0x05ed 05E9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @05DD stack[0] = 0x00 // @05DE stack[1] = 0x00 // } // Block ends with conditional jump to 0x05ed, if !(stack[-2] - stack[-1] i< 0x40) label_05EA: // Incoming jump from 0x05E9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @05EC memory[0x00:0x00] } 05EA 5F PUSH0 05EB 80 DUP1 05EC FD *REVERT // Stack delta = +0 // Outputs[1] { @05EC revert(memory[0x00:0x00]); } // Block terminates label_05ED: // Incoming jump from 0x05E9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @05F1 stack[-3] } 05ED 5B JUMPDEST 05EE 61 PUSH2 0x05f6 05F1 83 DUP4 05F2 61 PUSH2 0x05c1 05F5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @05EE stack[0] = 0x05f6 // @05F1 stack[1] = stack[-3] // } // Block ends with call to 0x05c1, returns to 0x05F6 label_05F6: // Incoming return from call to 0x05C1 at 0x05F5 // Inputs[5] // { // @05F7 stack[-6] // @05F7 stack[-1] // @05FA stack[-4] // @05FE msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @05FF stack[-5] // } 05F6 5B JUMPDEST 05F7 94 SWAP5 05F8 60 PUSH1 0x20 05FA 93 SWAP4 05FB 90 SWAP1 05FC 93 SWAP4 05FD 01 ADD 05FE 35 CALLDATALOAD 05FF 93 SWAP4 0600 50 POP 0601 50 POP 0602 50 POP 0603 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @05F7 stack[-6] = stack[-1] // @05FF stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_0604: // Incoming call from 0x00F4, returns to 0x00F5 // Inputs[2] // { // @060A stack[-1] // @060B stack[-2] // } 0604 5B JUMPDEST 0605 5F PUSH0 0606 80 DUP1 0607 5F PUSH0 0608 60 PUSH1 0x60 060A 84 DUP5 060B 86 DUP7 060C 03 SUB 060D 12 SLT 060E 15 ISZERO 060F 61 PUSH2 0x0616 0612 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0605 stack[0] = 0x00 // @0606 stack[1] = 0x00 // @0607 stack[2] = 0x00 // } // Block ends with conditional jump to 0x0616, if !(stack[-2] - stack[-1] i< 0x60) label_0613: // Incoming jump from 0x0612, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @0615 memory[0x00:0x00] } 0613 5F PUSH0 0614 80 DUP1 0615 FD *REVERT // Stack delta = +0 // Outputs[1] { @0615 revert(memory[0x00:0x00]); } // Block terminates label_0616: // Incoming jump from 0x0612, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @061A stack[-4] } 0616 5B JUMPDEST 0617 61 PUSH2 0x061f 061A 84 DUP5 061B 61 PUSH2 0x05c1 061E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0617 stack[0] = 0x061f // @061A stack[1] = stack[-4] // } // Block ends with call to 0x05c1, returns to 0x061F label_061F: // Incoming return from call to 0x05C1 at 0x061E // Inputs[3] // { // @0620 stack[-1] // @0620 stack[-4] // @0627 stack[-5] // } 061F 5B JUMPDEST 0620 92 SWAP3 0621 50 POP 0622 61 PUSH2 0x062d 0625 60 PUSH1 0x20 0627 85 DUP6 0628 01 ADD 0629 61 PUSH2 0x05c1 062C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0620 stack[-4] = stack[-1] // @0622 stack[-1] = 0x062d // @0628 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x05c1, returns to 0x062D label_062D: // Incoming return from call to 0x05C1 at 0x062C // Inputs[8] // { // @062E stack[-1] // @062E stack[-3] // @0632 stack[-5] // @0634 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @0635 stack[-2] // @0639 stack[-6] // @063B stack[-7] // @063B stack[-4] // } 062D 5B JUMPDEST 062E 91 SWAP2 062F 50 POP 0630 60 PUSH1 0x40 0632 84 DUP5 0633 01 ADD 0634 35 CALLDATALOAD 0635 90 SWAP1 0636 50 POP 0637 92 SWAP3 0638 50 POP 0639 92 SWAP3 063A 50 POP 063B 92 SWAP3 063C 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @0637 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @0639 stack[-6] = stack[-1] // @063B stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_063D: // Incoming call from 0x0138, returns to 0x0139 // Inputs[2] // { // @0641 stack[-1] // @0642 stack[-2] // } 063D 5B JUMPDEST 063E 5F PUSH0 063F 60 PUSH1 0x20 0641 82 DUP3 0642 84 DUP5 0643 03 SUB 0644 12 SLT 0645 15 ISZERO 0646 61 PUSH2 0x064d 0649 57 *JUMPI // Stack delta = +1 // Outputs[1] { @063E stack[0] = 0x00 } // Block ends with conditional jump to 0x064d, if !(stack[-2] - stack[-1] i< 0x20) label_064A: // Incoming jump from 0x0649, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @064C memory[0x00:0x00] } 064A 5F PUSH0 064B 80 DUP1 064C FD *REVERT // Stack delta = +0 // Outputs[1] { @064C revert(memory[0x00:0x00]); } // Block terminates label_064D: // Incoming jump from 0x0649, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0651 stack[-2] } 064D 5B JUMPDEST 064E 61 PUSH2 0x0656 0651 82 DUP3 0652 61 PUSH2 0x05c1 0655 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @064E stack[0] = 0x0656 // @0651 stack[1] = stack[-2] // } // Block ends with call to 0x05c1, returns to 0x0656 label_0656: // Incoming return from call to 0x05C1 at 0x0655 // Inputs[3] // { // @0657 stack[-1] // @0657 stack[-5] // @0658 stack[-4] // } 0656 5B JUMPDEST 0657 93 SWAP4 0658 92 SWAP3 0659 50 POP 065A 50 POP 065B 50 POP 065C 56 *JUMP // Stack delta = -4 // Outputs[1] { @0657 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_065D: // Incoming call from 0x017B, returns to 0x017C // Inputs[2] // { // @0662 stack[-1] // @0663 stack[-2] // } 065D 5B JUMPDEST 065E 5F PUSH0 065F 80 DUP1 0660 60 PUSH1 0x40 0662 83 DUP4 0663 85 DUP6 0664 03 SUB 0665 12 SLT 0666 15 ISZERO 0667 61 PUSH2 0x066e 066A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @065E stack[0] = 0x00 // @065F stack[1] = 0x00 // } // Block ends with conditional jump to 0x066e, if !(stack[-2] - stack[-1] i< 0x40) label_066B: // Incoming jump from 0x066A, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @066D memory[0x00:0x00] } 066B 5F PUSH0 066C 80 DUP1 066D FD *REVERT // Stack delta = +0 // Outputs[1] { @066D revert(memory[0x00:0x00]); } // Block terminates label_066E: // Incoming jump from 0x066A, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @0672 stack[-3] } 066E 5B JUMPDEST 066F 61 PUSH2 0x0677 0672 83 DUP4 0673 61 PUSH2 0x05c1 0676 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @066F stack[0] = 0x0677 // @0672 stack[1] = stack[-3] // } // Block ends with call to 0x05c1, returns to 0x0677 label_0677: // Incoming return from call to 0x05C1 at 0x0676 // Inputs[3] // { // @0678 stack[-3] // @0678 stack[-1] // @067F stack[-4] // } 0677 5B JUMPDEST 0678 91 SWAP2 0679 50 POP 067A 61 PUSH2 0x0685 067D 60 PUSH1 0x20 067F 84 DUP5 0680 01 ADD 0681 61 PUSH2 0x05c1 0684 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0678 stack[-3] = stack[-1] // @067A stack[-1] = 0x0685 // @0680 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x05c1, returns to 0x0685 label_0685: // Incoming return from call to 0x05C1 at 0x0684 // Inputs[6] // { // @0686 stack[-1] // @0686 stack[-2] // @0688 stack[-5] // @068A stack[-3] // @068A stack[-6] // @068B stack[-4] // } 0685 5B JUMPDEST 0686 90 SWAP1 0687 50 POP 0688 92 SWAP3 0689 50 POP 068A 92 SWAP3 068B 90 SWAP1 068C 50 POP 068D 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0688 stack[-5] = stack[-1] // @068A stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_068E: // Incoming call from 0x01B4, returns to 0x01B5 // Incoming call from 0x0280, returns to 0x01B5 // Incoming call from 0x01E0, returns to 0x01E1 // Inputs[1] { @0691 stack[-1] } 068E 5B JUMPDEST 068F 60 PUSH1 0x01 0691 81 DUP2 0692 81 DUP2 0693 1C SHR 0694 90 SWAP1 0695 82 DUP3 0696 16 AND 0697 80 DUP1 0698 61 PUSH2 0x06a2 069B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0694 stack[0] = stack[-1] >> 0x01 // @0696 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x06a2, if stack[-1] & 0x01 label_069C: // Incoming jump from 0x069B, if not stack[-1] & 0x01 // Inputs[2] // { // @069E stack[-2] // @06A7 stack[-1] // } 069C 60 PUSH1 0x7f 069E 82 DUP3 069F 16 AND 06A0 91 SWAP2 06A1 50 POP 06A2 5B JUMPDEST 06A3 60 PUSH1 0x20 06A5 82 DUP3 06A6 10 LT 06A7 81 DUP2 06A8 03 SUB 06A9 61 PUSH2 0x06c0 06AC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @06A0 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x06c0, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_06AD: // Incoming jump from 0x06AC, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x06AC, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @06BF memory[0x00:0x24] } 06AD 63 PUSH4 0x4e487b71 06B2 60 PUSH1 0xe0 06B4 1B SHL 06B5 5F PUSH0 06B6 52 MSTORE 06B7 60 PUSH1 0x22 06B9 60 PUSH1 0x04 06BB 52 MSTORE 06BC 60 PUSH1 0x24 06BE 5F PUSH0 06BF FD *REVERT // Stack delta = +0 // Outputs[3] // { // @06B6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @06BB memory[0x04:0x24] = 0x22 // @06BF revert(memory[0x00:0x24]); // } // Block terminates label_06C0: // Incoming jump from 0x06AC, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x06AC, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @06C2 stack[-4] // @06C2 stack[-2] // @06C3 stack[-3] // } 06C0 5B JUMPDEST 06C1 50 POP 06C2 91 SWAP2 06C3 90 SWAP1 06C4 50 POP 06C5 56 *JUMP // Stack delta = -3 // Outputs[1] { @06C2 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_06C6: // Incoming call from 0x046D, returns to 0x046E // Inputs[2] // { // @06C7 stack[-1] // @06C8 stack[-2] // } 06C6 5B JUMPDEST 06C7 80 DUP1 06C8 82 DUP3 06C9 01 ADD 06CA 80 DUP1 06CB 82 DUP3 06CC 11 GT 06CD 15 ISZERO 06CE 61 PUSH2 0x0249 06D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06C9 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x0249, if !(stack[-1] > stack[-2] + stack[-1]) label_06D2: // Incoming jump from 0x06D1, if not !(stack[-1] > stack[-2] + stack[-1]) // Inputs[1] { @06E4 memory[0x00:0x24] } 06D2 63 PUSH4 0x4e487b71 06D7 60 PUSH1 0xe0 06D9 1B SHL 06DA 5F PUSH0 06DB 52 MSTORE 06DC 60 PUSH1 0x11 06DE 60 PUSH1 0x04 06E0 52 MSTORE 06E1 60 PUSH1 0x24 06E3 5F PUSH0 06E4 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @06DB memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @06E0 memory[0x04:0x24] = 0x11 // @06E4 revert(memory[0x00:0x24]); // } // Block terminates 06E5 FE *ASSERT 06E6 A2 LOG2 06E7 64 PUSH5 0x6970667358 06ED 22 22 06EE 12 SLT 06EF 20 SHA3 06F0 03 SUB 06F1 CD CD 06F2 DC DC 06F3 47 SELFBALANCE 06F4 1E 1E 06F5 D8 D8 06F6 1A BYTE 06F7 0F 0F 06F8 16 AND 06F9 A9 A9 06FA C3 C3 06FB 26 26 06FC B6 B6 06FD 50 POP 06FE 36 CALLDATASIZE 06FF 37 CALLDATACOPY 0700 42 TIMESTAMP 0701 69 PUSH10 0x3d7aeaa9fe0a10c60dd8 070C 41 COINBASE 070D E6 E6 070E 17 OR 070F 39 CODECOPY 0710 64 PUSH5 0x736f6c6343 0716 00 *STOP 0717 08 ADDMOD 0718 17 OR 0719 00 *STOP 071A 33 CALLER