Last active
February 7, 2021 23:06
-
-
Save SamWilsn/f850807af39bdddbb88bbe44c787e376 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| entrypoint: | |
| // Inputs[1] { @0007 msg.data.length } | |
| 0000 60 PUSH1 0x80 [0x80] | |
| 0002 60 PUSH1 0x40 [0x40, 0x80] | |
| 0004 52 MSTORE [] // memory@0x40 := 0x80 | |
| 0005 60 PUSH1 0x04 [0x04] | |
| 0007 36 CALLDATASIZE [CSZ, 0x04] | |
| 0008 10 LT [C0] // CSZ < 0x04 | |
| 0009 61 PUSH2 0x0062 [0x62, C0] // revert_0062 | |
| 000C 57 *JUMPI [] | |
| // Stack delta = +0 | |
| // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } | |
| // Block ends with conditional jump to 0x0062 (revert_0062), if msg.data.length < 0x04 | |
| selector_0adf939b: | |
| // Incoming jump from 0x000C, if not msg.data.length < 0x04 | |
| // Inputs[1] { @000F msg.data[0x00:0x20] } | |
| 000D 60 PUSH1 0x00 [0x00] | |
| 000F 35 CALLDATALOAD [D0] | |
| 0010 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 | |
| 002E 90 SWAP1 [D0, 0x01..00] | |
| 002F 04 DIV [FSEL] // FSEL := D0 >> 28 | |
| 0030 63 PUSH4 0xffffffff [0xffffffff, FSEL] | |
| 0035 16 AND [FSEL] // FSEL := FSEL & 0xffffffff | |
| 0036 80 DUP1 [FSEL, FSEL] | |
| 0037 63 PUSH4 0x0adf939b [0x0adf939b, FSEL, FSEL] | |
| 003C 14 EQ [T2, FSEL] // T2 := FSEL == 0x0adf939b | |
| 003D 61 PUSH2 0x0067 [0x67, T2, FSEL] // (func_0adf939b) | |
| 0040 57 *JUMPI [FSEL] | |
| // Stack delta = +1 | |
| // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } | |
| // Block ends with conditional jump to 0x0067, if 0x0adf939b == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 | |
| selector_39ac0e49: | |
| // Incoming jump from 0x0040, if not 0x0adf939b == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 | |
| // Inputs[1] { @0041 stack[-1] } | |
| 0041 80 DUP1 [FSEL, FSEL] | |
| 0042 63 PUSH4 0x39ac0e49 [0x39ac0e49, FSEL, FSEL] | |
| 0047 14 EQ | |
| 0048 61 PUSH2 0x00f7 | |
| 004B 57 *JUMPI | |
| // Stack delta = +0 | |
| // Block ends with conditional jump to 0x00f7, if 0x39ac0e49 == stack[-1] | |
| label_004C: | |
| // Incoming jump from 0x004B, if not 0x39ac0e49 == stack[-1] | |
| // Inputs[1] { @004C stack[-1] } | |
| 004C 80 DUP1 | |
| 004D 63 PUSH4 0x799320bb | |
| 0052 14 EQ | |
| 0053 61 PUSH2 0x0187 | |
| 0056 57 *JUMPI | |
| // Stack delta = +0 | |
| // Block ends with conditional jump to 0x0187, if 0x799320bb == stack[-1] | |
| label_0057: | |
| // Incoming jump from 0x0056, if not 0x799320bb == stack[-1] | |
| // Inputs[1] { @0057 stack[-1] } | |
| 0057 80 DUP1 [FSEL, FSEL] | |
| 0058 63 PUSH4 0xb8b8d35a [0xb8b8d35a, FSEL, FSEL] | |
| 005D 14 EQ [Q, FSEL] | |
| 005E 61 PUSH2 0x01b6 [0x01b6, Q, FSEL] | |
| 0061 57 *JUMPI [FSEL] | |
| // Stack delta = +0 | |
| // Block ends with conditional jump to 0x01b6, if 0xb8b8d35a == stack[-1] | |
| revert_0062: | |
| // Incoming jump from 0x0061, if not 0xb8b8d35a == stack[-1] | |
| // Incoming jump from 0x000C, if msg.data.length < 0x04 | |
| // Inputs[1] { @0066 memory[0x00:0x00] } | |
| 0062 5B JUMPDEST | |
| 0063 60 PUSH1 0x00 | |
| 0065 80 DUP1 | |
| 0066 FD *REVERT | |
| // Stack delta = +0 | |
| // Outputs[1] { @0066 revert(memory[0x00:0x00]); } | |
| // Block terminates | |
| func_0adf939b: | |
| // Incoming jump from 0x0040, if 0x0adf939b == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 | |
| // Inputs[1] { @0068 msg.value } | |
| 0067 5B JUMPDEST | |
| 0068 34 CALLVALUE | |
| 0069 80 DUP1 | |
| 006A 15 ISZERO | |
| 006B 61 PUSH2 0x0073 | |
| 006E 57 *JUMPI | |
| // Stack delta = +1 | |
| // Outputs[1] { @0068 stack[0] = msg.value } | |
| // Block ends with conditional jump to 0x0073, if !msg.value | |
| label_006F: | |
| // Incoming jump from 0x006E, if not !msg.value | |
| // Inputs[1] { @0072 memory[0x00:0x00] } | |
| 006F 60 PUSH1 0x00 | |
| 0071 80 DUP1 | |
| 0072 FD *REVERT | |
| // Stack delta = +0 | |
| // Outputs[1] { @0072 revert(memory[0x00:0x00]); } | |
| // Block terminates | |
| label_0073: | |
| // Incoming jump from 0x006E, if !msg.value | |
| 0073 5B JUMPDEST | |
| 0074 50 POP | |
| 0075 61 PUSH2 0x007c | |
| 0078 61 PUSH2 0x01e3 | |
| 007B 56 *JUMP | |
| // Stack delta = +0 | |
| // Outputs[1] { @0075 stack[-1] = 0x007c } | |
| // Block ends with call to 0x01e3, returns to 0x007C | |
| label_007C: | |
| // Incoming return from call to 0x01E3 at 0x007B | |
| // Inputs[4] | |
| // { | |
| // @007F memory[0x40:0x60] | |
| // @008A stack[-1] | |
| // @008D memory[stack[-1]:stack[-1] + 0x20] | |
| // @0096 memory[stack[-1]:stack[-1] + 0x20] | |
| // } | |
| 007C 5B JUMPDEST | |
| 007D 60 PUSH1 0x40 | |
| 007F 51 MLOAD | |
| 0080 80 DUP1 | |
| 0081 80 DUP1 | |
| 0082 60 PUSH1 0x20 | |
| 0084 01 ADD | |
| 0085 82 DUP3 | |
| 0086 81 DUP2 | |
| 0087 03 SUB | |
| 0088 82 DUP3 | |
| 0089 52 MSTORE | |
| 008A 83 DUP4 | |
| 008B 81 DUP2 | |
| 008C 81 DUP2 | |
| 008D 51 MLOAD | |
| 008E 81 DUP2 | |
| 008F 52 MSTORE | |
| 0090 60 PUSH1 0x20 | |
| 0092 01 ADD | |
| 0093 91 SWAP2 | |
| 0094 50 POP | |
| 0095 80 DUP1 | |
| 0096 51 MLOAD | |
| 0097 90 SWAP1 | |
| 0098 60 PUSH1 0x20 | |
| 009A 01 ADD | |
| 009B 90 SWAP1 | |
| 009C 80 DUP1 | |
| 009D 83 DUP4 | |
| 009E 83 DUP4 | |
| 009F 60 PUSH1 0x00 | |
| 00A1 5B JUMPDEST | |
| 00A2 83 DUP4 | |
| 00A3 81 DUP2 | |
| 00A4 10 LT | |
| 00A5 15 ISZERO | |
| 00A6 61 PUSH2 0x00bc | |
| 00A9 57 *JUMPI | |
| // Stack delta = +9 | |
| // Outputs[11] | |
| // { | |
| // @007F stack[0] = memory[0x40:0x60] | |
| // @0080 stack[1] = memory[0x40:0x60] | |
| // @0089 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] | |
| // @008F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] | |
| // @0093 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] | |
| // @009B stack[4] = memory[stack[-1]:stack[-1] + 0x20] | |
| // @009B stack[3] = 0x20 + stack[-1] | |
| // @009C stack[5] = memory[stack[-1]:stack[-1] + 0x20] | |
| // @009D stack[6] = 0x20 + 0x20 + memory[0x40:0x60] | |
| // @009E stack[7] = 0x20 + stack[-1] | |
| // @009F stack[8] = 0x00 | |
| // } | |
| // Block ends with conditional jump to 0x00bc, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) | |
| label_00AA: | |
| // Incoming jump from 0x00A9, if not !(stack[-1] < stack[-4]) | |
| // Incoming jump from 0x00A9, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) | |
| // Inputs[4] | |
| // { | |
| // @00AA stack[-1] | |
| // @00AB stack[-2] | |
| // @00AD memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] | |
| // @00AF stack[-3] | |
| // } | |
| 00AA 80 DUP1 | |
| 00AB 82 DUP3 | |
| 00AC 01 ADD | |
| 00AD 51 MLOAD | |
| 00AE 81 DUP2 | |
| 00AF 84 DUP5 | |
| 00B0 01 ADD | |
| 00B1 52 MSTORE | |
| 00B2 60 PUSH1 0x20 | |
| 00B4 81 DUP2 | |
| 00B5 01 ADD | |
| 00B6 90 SWAP1 | |
| 00B7 50 POP | |
| 00B8 61 PUSH2 0x00a1 | |
| 00BB 56 *JUMP | |
| // Stack delta = +0 | |
| // Outputs[2] | |
| // { | |
| // @00B1 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] | |
| // @00B6 stack[-1] = stack[-1] + 0x20 | |
| // } | |
| // Block ends with unconditional jump to 0x00a1 | |
| label_00BC: | |
| // Incoming jump from 0x00A9, if !(stack[-1] < stack[-4]) | |
| // Incoming jump from 0x00A9, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) | |
| // Inputs[3] | |
| // { | |
| // @00C1 stack[-5] | |
| // @00C1 stack[-6] | |
| // @00C3 stack[-7] | |
| // } | |
| 00BC 5B JUMPDEST | |
| 00BD 50 POP | |
| 00BE 50 POP | |
| 00BF 50 POP | |
| 00C0 50 POP | |
| 00C1 90 SWAP1 | |
| 00C2 50 POP | |
| 00C3 90 SWAP1 | |
| 00C4 81 DUP2 | |
| 00C5 01 ADD | |
| 00C6 90 SWAP1 | |
| 00C7 60 PUSH1 0x1f | |
| 00C9 16 AND | |
| 00CA 80 DUP1 | |
| 00CB 15 ISZERO | |
| 00CC 61 PUSH2 0x00e9 | |
| 00CF 57 *JUMPI | |
| // Stack delta = -5 | |
| // Outputs[2] | |
| // { | |
| // @00C6 stack[-7] = stack[-5] + stack[-7] | |
| // @00C9 stack[-6] = 0x1f & stack[-5] | |
| // } | |
| // Block ends with conditional jump to 0x00e9, if !(0x1f & stack[-5]) | |
| label_00D0: | |
| // Incoming jump from 0x00CF, if not !(0x1f & stack[-5]) | |
| // Inputs[6] | |
| // { | |
| // @00D0 stack[-1] | |
| // @00D1 stack[-2] | |
| // @00D4 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] | |
| // @00EB stack[-5] | |
| // @00F1 memory[0x40:0x60] | |
| // @00F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] | |
| // } | |
| 00D0 80 DUP1 | |
| 00D1 82 DUP3 | |
| 00D2 03 SUB | |
| 00D3 80 DUP1 | |
| 00D4 51 MLOAD | |
| 00D5 60 PUSH1 0x01 | |
| 00D7 83 DUP4 | |
| 00D8 60 PUSH1 0x20 | |
| 00DA 03 SUB | |
| 00DB 61 PUSH2 0x0100 | |
| 00DE 0A EXP | |
| 00DF 03 SUB | |
| 00E0 19 NOT | |
| 00E1 16 AND | |
| 00E2 81 DUP2 | |
| 00E3 52 MSTORE | |
| 00E4 60 PUSH1 0x20 | |
| 00E6 01 ADD | |
| 00E7 91 SWAP2 | |
| 00E8 50 POP | |
| 00E9 5B JUMPDEST | |
| 00EA 50 POP | |
| 00EB 92 SWAP3 | |
| 00EC 50 POP | |
| 00ED 50 POP | |
| 00EE 50 POP | |
| 00EF 60 PUSH1 0x40 | |
| 00F1 51 MLOAD | |
| 00F2 80 DUP1 | |
| 00F3 91 SWAP2 | |
| 00F4 03 SUB | |
| 00F5 90 SWAP1 | |
| 00F6 F3 *RETURN | |
| // Stack delta = -5 | |
| // Outputs[2] | |
| // { | |
| // @00E3 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] | |
| // @00F6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; | |
| // } | |
| // Block terminates | |
| label_00F7: | |
| // Incoming jump from 0x004B, if 0x39ac0e49 == stack[-1] | |
| // Inputs[1] { @00F8 msg.value } | |
| 00F7 5B JUMPDEST | |
| 00F8 34 CALLVALUE | |
| 00F9 80 DUP1 | |
| 00FA 15 ISZERO | |
| 00FB 61 PUSH2 0x0103 | |
| 00FE 57 *JUMPI | |
| // Stack delta = +1 | |
| // Outputs[1] { @00F8 stack[0] = msg.value } | |
| // Block ends with conditional jump to 0x0103, if !msg.value | |
| label_00FF: | |
| // Incoming jump from 0x00FE, if not !msg.value | |
| // Inputs[1] { @0102 memory[0x00:0x00] } | |
| 00FF 60 PUSH1 0x00 | |
| 0101 80 DUP1 | |
| 0102 FD *REVERT | |
| // Stack delta = +0 | |
| // Outputs[1] { @0102 revert(memory[0x00:0x00]); } | |
| // Block terminates | |
| label_0103: | |
| // Incoming jump from 0x00FE, if !msg.value | |
| 0103 5B JUMPDEST | |
| 0104 50 POP | |
| 0105 61 PUSH2 0x010c | |
| 0108 61 PUSH2 0x0243 | |
| 010B 56 *JUMP | |
| // Stack delta = +0 | |
| // Outputs[1] { @0105 stack[-1] = 0x010c } | |
| // Block ends with call to 0x0243, returns to 0x010C | |
| label_010C: | |
| // Incoming return from call to 0x0243 at 0x010B | |
| // Inputs[4] | |
| // { | |
| // @010F memory[0x40:0x60] | |
| // @011A stack[-1] | |
| // @011D memory[stack[-1]:stack[-1] + 0x20] | |
| // @0126 memory[stack[-1]:stack[-1] + 0x20] | |
| // } | |
| 010C 5B JUMPDEST | |
| 010D 60 PUSH1 0x40 | |
| 010F 51 MLOAD | |
| 0110 80 DUP1 | |
| 0111 80 DUP1 | |
| 0112 60 PUSH1 0x20 | |
| 0114 01 ADD | |
| 0115 82 DUP3 | |
| 0116 81 DUP2 | |
| 0117 03 SUB | |
| 0118 82 DUP3 | |
| 0119 52 MSTORE | |
| 011A 83 DUP4 | |
| 011B 81 DUP2 | |
| 011C 81 DUP2 | |
| 011D 51 MLOAD | |
| 011E 81 DUP2 | |
| 011F 52 MSTORE | |
| 0120 60 PUSH1 0x20 | |
| 0122 01 ADD | |
| 0123 91 SWAP2 | |
| 0124 50 POP | |
| 0125 80 DUP1 | |
| 0126 51 MLOAD | |
| 0127 90 SWAP1 | |
| 0128 60 PUSH1 0x20 | |
| 012A 01 ADD | |
| 012B 90 SWAP1 | |
| 012C 80 DUP1 | |
| 012D 83 DUP4 | |
| 012E 83 DUP4 | |
| 012F 60 PUSH1 0x00 | |
| 0131 5B JUMPDEST | |
| 0132 83 DUP4 | |
| 0133 81 DUP2 | |
| 0134 10 LT | |
| 0135 15 ISZERO | |
| 0136 61 PUSH2 0x014c | |
| 0139 57 *JUMPI | |
| // Stack delta = +9 | |
| // Outputs[11] | |
| // { | |
| // @010F stack[0] = memory[0x40:0x60] | |
| // @0110 stack[1] = memory[0x40:0x60] | |
| // @0119 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] | |
| // @011F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] | |
| // @0123 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] | |
| // @012B stack[4] = memory[stack[-1]:stack[-1] + 0x20] | |
| // @012B stack[3] = 0x20 + stack[-1] | |
| // @012C stack[5] = memory[stack[-1]:stack[-1] + 0x20] | |
| // @012D stack[6] = 0x20 + 0x20 + memory[0x40:0x60] | |
| // @012E stack[7] = 0x20 + stack[-1] | |
| // @012F stack[8] = 0x00 | |
| // } | |
| // Block ends with conditional jump to 0x014c, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) | |
| label_013A: | |
| // Incoming jump from 0x0139, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) | |
| // Incoming jump from 0x0139, if not !(stack[-1] < stack[-4]) | |
| // Inputs[4] | |
| // { | |
| // @013A stack[-1] | |
| // @013B stack[-2] | |
| // @013D memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] | |
| // @013F stack[-3] | |
| // } | |
| 013A 80 DUP1 | |
| 013B 82 DUP3 | |
| 013C 01 ADD | |
| 013D 51 MLOAD | |
| 013E 81 DUP2 | |
| 013F 84 DUP5 | |
| 0140 01 ADD | |
| 0141 52 MSTORE | |
| 0142 60 PUSH1 0x20 | |
| 0144 81 DUP2 | |
| 0145 01 ADD | |
| 0146 90 SWAP1 | |
| 0147 50 POP | |
| 0148 61 PUSH2 0x0131 | |
| 014B 56 *JUMP | |
| // Stack delta = +0 | |
| // Outputs[2] | |
| // { | |
| // @0141 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] | |
| // @0146 stack[-1] = stack[-1] + 0x20 | |
| // } | |
| // Block ends with unconditional jump to 0x0131 | |
| label_014C: | |
| // Incoming jump from 0x0139, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) | |
| // Incoming jump from 0x0139, if !(stack[-1] < stack[-4]) | |
| // Inputs[3] | |
| // { | |
| // @0151 stack[-5] | |
| // @0151 stack[-6] | |
| // @0153 stack[-7] | |
| // } | |
| 014C 5B JUMPDEST | |
| 014D 50 POP | |
| 014E 50 POP | |
| 014F 50 POP | |
| 0150 50 POP | |
| 0151 90 SWAP1 | |
| 0152 50 POP | |
| 0153 90 SWAP1 | |
| 0154 81 DUP2 | |
| 0155 01 ADD | |
| 0156 90 SWAP1 | |
| 0157 60 PUSH1 0x1f | |
| 0159 16 AND | |
| 015A 80 DUP1 | |
| 015B 15 ISZERO | |
| 015C 61 PUSH2 0x0179 | |
| 015F 57 *JUMPI | |
| // Stack delta = -5 | |
| // Outputs[2] | |
| // { | |
| // @0156 stack[-7] = stack[-5] + stack[-7] | |
| // @0159 stack[-6] = 0x1f & stack[-5] | |
| // } | |
| // Block ends with conditional jump to 0x0179, if !(0x1f & stack[-5]) | |
| label_0160: | |
| // Incoming jump from 0x015F, if not !(0x1f & stack[-5]) | |
| // Inputs[6] | |
| // { | |
| // @0160 stack[-1] | |
| // @0161 stack[-2] | |
| // @0164 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] | |
| // @017B stack[-5] | |
| // @0181 memory[0x40:0x60] | |
| // @0186 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] | |
| // } | |
| 0160 80 DUP1 | |
| 0161 82 DUP3 | |
| 0162 03 SUB | |
| 0163 80 DUP1 | |
| 0164 51 MLOAD | |
| 0165 60 PUSH1 0x01 | |
| 0167 83 DUP4 | |
| 0168 60 PUSH1 0x20 | |
| 016A 03 SUB | |
| 016B 61 PUSH2 0x0100 | |
| 016E 0A EXP | |
| 016F 03 SUB | |
| 0170 19 NOT | |
| 0171 16 AND | |
| 0172 81 DUP2 | |
| 0173 52 MSTORE | |
| 0174 60 PUSH1 0x20 | |
| 0176 01 ADD | |
| 0177 91 SWAP2 | |
| 0178 50 POP | |
| 0179 5B JUMPDEST | |
| 017A 50 POP | |
| 017B 92 SWAP3 | |
| 017C 50 POP | |
| 017D 50 POP | |
| 017E 50 POP | |
| 017F 60 PUSH1 0x40 | |
| 0181 51 MLOAD | |
| 0182 80 DUP1 | |
| 0183 91 SWAP2 | |
| 0184 03 SUB | |
| 0185 90 SWAP1 | |
| 0186 F3 *RETURN | |
| // Stack delta = -5 | |
| // Outputs[2] | |
| // { | |
| // @0173 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] | |
| // @0186 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; | |
| // } | |
| // Block terminates | |
| label_0187: | |
| // Incoming jump from 0x0056, if 0x799320bb == stack[-1] | |
| // Inputs[1] { @0188 msg.value } | |
| 0187 5B JUMPDEST | |
| 0188 34 CALLVALUE | |
| 0189 80 DUP1 | |
| 018A 15 ISZERO | |
| 018B 61 PUSH2 0x0193 | |
| 018E 57 *JUMPI | |
| // Stack delta = +1 | |
| // Outputs[1] { @0188 stack[0] = msg.value } | |
| // Block ends with conditional jump to 0x0193, if !msg.value | |
| label_018F: | |
| // Incoming jump from 0x018E, if not !msg.value | |
| // Inputs[1] { @0192 memory[0x00:0x00] } | |
| 018F 60 PUSH1 0x00 | |
| 0191 80 DUP1 | |
| 0192 FD *REVERT | |
| // Stack delta = +0 | |
| // Outputs[1] { @0192 revert(memory[0x00:0x00]); } | |
| // Block terminates | |
| label_0193: | |
| // Incoming jump from 0x018E, if !msg.value | |
| 0193 5B JUMPDEST | |
| 0194 50 POP | |
| 0195 61 PUSH2 0x019c | |
| 0198 61 PUSH2 0x02a3 | |
| 019B 56 *JUMP | |
| // Stack delta = +0 | |
| // Outputs[1] { @0195 stack[-1] = 0x019c } | |
| // Block ends with call to 0x02a3, returns to 0x019C | |
| label_019C: | |
| // Incoming return from call to 0x02A3 at 0x019B | |
| // Inputs[4] | |
| // { | |
| // @019F memory[0x40:0x60] | |
| // @01A1 stack[-1] | |
| // @01B0 memory[0x40:0x60] | |
| // @01B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] | |
| // } | |
| 019C 5B JUMPDEST | |
| 019D 60 PUSH1 0x40 | |
| 019F 51 MLOAD | |
| 01A0 80 DUP1 | |
| 01A1 82 DUP3 | |
| 01A2 15 ISZERO | |
| 01A3 15 ISZERO | |
| 01A4 15 ISZERO | |
| 01A5 15 ISZERO | |
| 01A6 81 DUP2 | |
| 01A7 52 MSTORE | |
| 01A8 60 PUSH1 0x20 | |
| 01AA 01 ADD | |
| 01AB 91 SWAP2 | |
| 01AC 50 POP | |
| 01AD 50 POP | |
| 01AE 60 PUSH1 0x40 | |
| 01B0 51 MLOAD | |
| 01B1 80 DUP1 | |
| 01B2 91 SWAP2 | |
| 01B3 03 SUB | |
| 01B4 90 SWAP1 | |
| 01B5 F3 *RETURN | |
| // Stack delta = -1 | |
| // Outputs[2] | |
| // { | |
| // @01A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] | |
| // @01B5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; | |
| // } | |
| // Block terminates | |
| label_01B6: | |
| // Incoming jump from 0x0061, if 0xb8b8d35a == stack[-1] | |
| // Inputs[1] { @01B7 msg.value } | |
| 01B6 5B JUMPDEST [FSEL] | |
| // Checks msg.value == 0 for func_b8b8d35a | |
| 01B7 34 CALLVALUE [VAL, FSEL] | |
| 01B8 80 DUP1 [VAL, VAL, FSEL] | |
| 01B9 15 ISZERO [!VAL, VAL, FSEL] | |
| 01BA 61 PUSH2 0x01c2 [0x01c2, !VAL, VAL, FSEL] | |
| 01BD 57 *JUMPI [VAL, FSEL] | |
| // Stack delta = +1 | |
| // Outputs[1] { @01B7 stack[0] = msg.value } | |
| // Block ends with conditional jump to 0x01c2, if !msg.value | |
| label_01BE: | |
| // Incoming jump from 0x01BD, if not !msg.value | |
| // Inputs[1] { @01C1 memory[0x00:0x00] } | |
| 01BE 60 PUSH1 0x00 | |
| 01C0 80 DUP1 | |
| 01C1 FD *REVERT | |
| // Stack delta = +0 | |
| // Outputs[1] { @01C1 revert(memory[0x00:0x00]); } | |
| // Block terminates | |
| label_01C2: | |
| // Incoming jump from 0x01BD, if !msg.value | |
| // Inputs[2] | |
| // { | |
| // @01CA msg.data.length | |
| // @01D1 msg.data[0x04:0x24] | |
| // } | |
| 01C2 5B JUMPDEST [0x00, FSEL] | |
| 01C3 50 POP [FSEL] | |
| 01C4 61 PUSH2 0x01e1 [0x01e1, FSEL] | |
| 01C7 60 PUSH1 0x04 [0x04, 0x01e1, FSEL] | |
| 01C9 80 DUP1 [0x04, 0x04, 0x01e1, FSEL] | |
| 01CA 36 CALLDATASIZE [CSZ, 0x04, 0x04, 0x01e1, FSEL] | |
| 01CB 03 SUB [ARGSZ, 0x04, 0x01e1, FSEL] | |
| 01CC 81 DUP2 [0x04, ARGSZ, 0x04, 0x01e1, FSEL] | |
| 01CD 01 ADD [CSZ, 0x04, 0x01e1, FSEL] | |
| 01CE 90 SWAP1 [0x04, CSZ, 0x01e1, FSEL] | |
| 01CF 80 DUP1 [0x04, 0x04, CSZ, 0x01e1, FSEL] | |
| 01D0 80 DUP1 [0x04, 0x04, 0x04, CSZ, 0x01e1, FSEL] | |
| 01D1 35 CALLDATALOAD [C, 0x04, 0x04, CSZ, 0x01e1, FSEL] | |
| 01D2 90 SWAP1 [0x04, C, 0x04, CSZ, 0x01e1, FSEL] | |
| 01D3 60 PUSH1 0x20 [0x20, 0x04, C, 0x04, CSZ, 0x01e1, FSEL] | |
| 01D5 01 ADD [0x24, C, 0x04, CSZ, 0x01e1, FSEL] | |
| 01D6 90 SWAP1 [C, 0x24, 0x04, CSZ, 0x01e1, FSEL] | |
| 01D7 92 SWAP3 [CSZ, 0x24, 0x04, C, 0x01e1, FSEL] | |
| 01D8 91 SWAP2 [0x04, 0x24, CSZ, C, 0x01e1, FSEL] | |
| 01D9 90 SWAP1 [0x24, 0x04, CSZ, C, 0x01e1, FSEL] | |
| 01DA 50 POP [0x04, CSZ, C, 0x01e1, FSEL] | |
| 01DB 50 POP [CSZ, C, 0x01e1, FSEL] | |
| 01DC 50 POP [C, 0x01e1, FSEL] | |
| 01DD 61 PUSH2 0x02b5 [0x02b5, C, 0x01e1, FSEL] | |
| 01E0 56 *JUMP [C, 0x01e1, FSEL] | |
| // Stack delta = +1 | |
| // Outputs[2] | |
| // { | |
| // @01C4 stack[-1] = 0x01e1 | |
| // @01D7 stack[0] = msg.data[0x04:0x24] | |
| // } | |
| // Block ends with call to 0x02b5, returns to 0x01E1 | |
| label_01E1: | |
| // Incoming return from call to 0x02B5 at 0x01E0 | |
| 01E1 5B JUMPDEST | |
| 01E2 00 *STOP | |
| // Stack delta = +0 | |
| // Outputs[1] { @01E2 stop(); } | |
| // Block terminates | |
| label_01E3: | |
| // Incoming call from 0x007B, returns to 0x007C | |
| // Inputs[2] | |
| // { | |
| // @01E8 memory[0x40:0x60] | |
| // @0241 stack[-1] | |
| // } | |
| 01E3 5B JUMPDEST | |
| 01E4 60 PUSH1 0x60 | |
| 01E6 60 PUSH1 0x40 | |
| 01E8 51 MLOAD | |
| 01E9 90 SWAP1 | |
| 01EA 81 DUP2 | |
| 01EB 01 ADD | |
| 01EC 60 PUSH1 0x40 | |
| 01EE 52 MSTORE | |
| 01EF 80 DUP1 | |
| 01F0 60 PUSH1 0x26 | |
| 01F2 81 DUP2 | |
| 01F3 52 MSTORE | |
| 01F4 60 PUSH1 0x20 | |
| 01F6 01 ADD | |
| 01F7 7F PUSH32 0x311dfa5451963f33b16e63f0c62278c9b907e43d1961cdf9f590a0c3b351c040 | |
| 0218 81 DUP2 | |
| 0219 52 MSTORE | |
| 021A 60 PUSH1 0x20 | |
| 021C 01 ADD | |
| 021D 7F PUSH32 0x19cccb8314030000000000000000000000000000000000000000000000000000 | |
| 023E 81 DUP2 | |
| 023F 52 MSTORE | |
| 0240 50 POP | |
| 0241 81 DUP2 | |
| 0242 56 *JUMP | |
| // Stack delta = +1 | |
| // Outputs[5] | |
| // { | |
| // @01E9 stack[0] = memory[0x40:0x60] | |
| // @01EE memory[0x40:0x60] = memory[0x40:0x60] + 0x60 | |
| // @01F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 | |
| // @0219 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x311dfa5451963f33b16e63f0c62278c9b907e43d1961cdf9f590a0c3b351c040 | |
| // @023F memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x19cccb8314030000000000000000000000000000000000000000000000000000 | |
| // } | |
| // Block ends with unconditional jump to stack[-1] | |
| label_0243: | |
| // Incoming call from 0x010B, returns to 0x010C | |
| // Inputs[2] | |
| // { | |
| // @0248 memory[0x40:0x60] | |
| // @02A1 stack[-1] | |
| // } | |
| 0243 5B JUMPDEST | |
| 0244 60 PUSH1 0x60 | |
| 0246 60 PUSH1 0x40 | |
| 0248 51 MLOAD | |
| 0249 90 SWAP1 | |
| 024A 81 DUP2 | |
| 024B 01 ADD | |
| 024C 60 PUSH1 0x40 | |
| 024E 52 MSTORE | |
| 024F 80 DUP1 | |
| 0250 60 PUSH1 0x26 | |
| 0252 81 DUP2 | |
| 0253 52 MSTORE | |
| 0254 60 PUSH1 0x20 | |
| 0256 01 ADD | |
| 0257 7F PUSH32 0x504354467b763332795f3533637532335f336e633279703731306e5f34313930 | |
| 0278 81 DUP2 | |
| 0279 52 MSTORE | |
| 027A 60 PUSH1 0x20 | |
| 027C 01 ADD | |
| 027D 7F PUSH32 0x323137686d7d0000000000000000000000000000000000000000000000000000 | |
| 029E 81 DUP2 | |
| 029F 52 MSTORE | |
| 02A0 50 POP | |
| 02A1 81 DUP2 | |
| 02A2 56 *JUMP | |
| // Stack delta = +1 | |
| // Outputs[5] | |
| // { | |
| // @0249 stack[0] = memory[0x40:0x60] | |
| // @024E memory[0x40:0x60] = memory[0x40:0x60] + 0x60 | |
| // @0253 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 | |
| // @0279 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x504354467b763332795f3533637532335f336e633279703731306e5f34313930 | |
| // @029F memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x323137686d7d0000000000000000000000000000000000000000000000000000 | |
| // } | |
| // Block ends with unconditional jump to stack[-1] | |
| label_02A3: | |
| // Incoming call from 0x019B, returns to 0x019C | |
| // Inputs[2] | |
| // { | |
| // @02A8 storage[0x00] | |
| // @02B3 stack[-1] | |
| // } | |
| 02A3 5B JUMPDEST | |
| 02A4 60 PUSH1 0x00 | |
| 02A6 80 DUP1 | |
| 02A7 90 SWAP1 | |
| 02A8 54 SLOAD | |
| 02A9 90 SWAP1 | |
| 02AA 61 PUSH2 0x0100 | |
| 02AD 0A EXP | |
| 02AE 90 SWAP1 | |
| 02AF 04 DIV | |
| 02B0 60 PUSH1 0xff | |
| 02B2 16 AND | |
| 02B3 81 DUP2 | |
| 02B4 56 *JUMP | |
| // Stack delta = +1 | |
| // Outputs[1] { @02B2 stack[0] = 0xff & storage[0x00] / 0x0100 ** 0x00 } | |
| // Block ends with unconditional jump to stack[-1] | |
| label_02B5: | |
| // Something to do with func_b8b8d35a | |
| // Incoming call from 0x01E0, returns to 0x01E1 | |
| 02B5 5B JUMPDEST [C, 0x01e1, FSEL] | |
| 02B6 61 PUSH2 0x02bd [0x02bd, C, 0x01e1, FSEL] | |
| 02B9 61 PUSH2 0x11d2 [0x11d2, 0x02bd, C, 0x01e1, FSEL] | |
| 02BC 56 *JUMP [0x02bd, C, 0x01e1, FSEL] | |
| // Stack delta = +1 | |
| // Outputs[1] { @02B6 stack[0] = 0x02bd } | |
| // Block ends with call to 0x11d2, returns to 0x02BD | |
| label_02BD: | |
| // Incoming return from call to 0x11D2 at 0x02BC | |
| // Inputs[4] | |
| // { | |
| // @02C6 memory[0x40:0x60] | |
| // @031F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // @0324 memory[0x40:0x60] | |
| // @037D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // } | |
| 02BD 5B JUMPDEST [M_Z0, C, 0x01e1, FSEL] | |
| 02BE 60 PUSH1 0x60 [0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02C0 60 PUSH1 0x00 [0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| // Allocating 0x60 bytes | |
| 02C2 60 PUSH1 0x60 [0x60, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02C4 60 PUSH1 0x40 [0x40, 0x60, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02C6 51 MLOAD [M_Y0, 0x60, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02C7 90 SWAP1 [0x60, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02C8 81 DUP2 [M_Y0, 0x60, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02C9 01 ADD [M_X0, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02CA 60 PUSH1 0x40 [0x40, M_X0, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02CC 52 MSTORE [M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@0x40 := M_X0 | |
| // Writes the constants from func_ | |
| 02CD 80 DUP1 [M_Y0, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02CE 60 PUSH1 0x26 [0x26, M_Y0, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02D0 81 DUP2 [M_Y0, 0x26, M_Y0, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02D1 52 MSTORE [M_Y0, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@M_Y0 := 0x00..0026 | |
| 02D2 60 PUSH1 0x20 [0x20, M_Y0, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02D4 01 ADD [M_Y1, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02D5 7F PUSH32 0x504354467b763332795f3533637532335f336e633279703731306e5f34313930 | |
| [0x50..30, M_Y1, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02F6 81 DUP2 [M_Y1, 0x50..30, M_Y1, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02F7 52 MSTORE [M_Y1, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@M_Y1 := 0x55..30 | |
| 02F8 60 PUSH1 0x20 [0x20, M_Y1, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02FA 01 ADD [M_Y2, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 02FB 7F PUSH32 0x323137686d7d0000000000000000000000000000000000000000000000000000 | |
| [0x32..00, M_Y2, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 031C 81 DUP2 [M_Y2, 0x32..00, M_Y2, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 031D 52 MSTORE [M_Y2, M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@M_Y2 := 0x32..00 | |
| 031E 50 POP [M_Y0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| // Read the constant? | |
| 031F 51 MLOAD [0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| // Allocate another 0x60 bytes. | |
| 0320 60 PUSH1 0x60 [0x60, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0322 60 PUSH1 0x40 [0x40, 0x60, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0324 51 MLOAD [M_X0, 0x60, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0325 90 SWAP1 [0x60, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0326 81 DUP2 [M_X0, 0x60, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0327 01 ADD [M_W0, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0328 60 PUSH1 0x40 [0x40, M_W0, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 032A 52 MSTORE [M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@0x40 := M_W0 | |
| 032B 80 DUP1 [M_X0, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 032C 60 PUSH1 0x26 [0x26, M_X0, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 032E 81 DUP2 [M_X0, 0x26, M_X0, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 032F 52 MSTORE [M_X0, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@MX_0 := 0x26 | |
| 0330 60 PUSH1 0x20 [0x20, M_X0, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0332 01 ADD [M_X1, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0333 7F PUSH32 0x311dfa5451963f33b16e63f0c62278c9b907e43d1961cdf9f590a0c3b351c040 | |
| [0x31..40, M_X1, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0354 81 DUP2 [M_X1, 0x31..40, M_X1, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0355 52 MSTORE [M_X1, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@M_X1 := 0x31..40 | |
| 0356 60 PUSH1 0x20 [0x20, M_X1, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0358 01 ADD [M_X2, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0359 7F PUSH32 0x19cccb8314030000000000000000000000000000000000000000000000000000 | |
| [0x19..00, M_X2, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 037A 81 DUP2 [M_X2, 0x19..00, M_X2, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 037B 52 MSTORE [M_X2, M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@M_X2 := 0x19..00 | |
| 037C 50 POP [M_X0, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 037D 51 MLOAD [0x26, 0x26, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 037E 14 EQ [0x01, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 037F 15 ISZERO [0x00, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0380 15 ISZERO [0x01, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0381 61 PUSH2 0x0389 [0x0389, 0x01, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0384 57 *JUMPI [0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| // Stack delta = +2 | |
| // Outputs[10] | |
| // { | |
| // @02BE stack[0] = 0x60 | |
| // @02C0 stack[1] = 0x00 | |
| // @02CC memory[0x40:0x60] = memory[0x40:0x60] + 0x60 | |
| // @02D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 | |
| // @02F7 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x504354467b763332795f3533637532335f336e633279703731306e5f34313930 | |
| // @031D memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x323137686d7d0000000000000000000000000000000000000000000000000000 | |
| // @032A memory[0x40:0x60] = memory[0x40:0x60] + 0x60 | |
| // @032F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 | |
| // @0355 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x311dfa5451963f33b16e63f0c62278c9b907e43d1961cdf9f590a0c3b351c040 | |
| // @037B memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x19cccb8314030000000000000000000000000000000000000000000000000000 | |
| // } | |
| // Block ends with conditional jump to 0x0389, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] == memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) | |
| label_0385: | |
| // Incoming jump from 0x0384, if not !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] == memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) | |
| // Inputs[1] { @0388 memory[0x00:0x00] } | |
| 0385 60 PUSH1 0x00 | |
| 0387 80 DUP1 | |
| 0388 FD *REVERT | |
| // Stack delta = +0 | |
| // Outputs[1] { @0388 revert(memory[0x00:0x00]); } | |
| // Block terminates | |
| label_0389: | |
| // Incoming jump from 0x0384, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] == memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) | |
| // Inputs[6] | |
| // { | |
| // @038F memory[0x40:0x60] | |
| // @0D94 stack[-3] | |
| // @0D9A memory[0x40:0x60] | |
| // @0DF3 stack[-2] | |
| // @0DF7 stack[-1] | |
| // @0DFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // } | |
| 0389 5B JUMPDEST [0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| // Expands free memory by 0x2000 bytes | |
| 038A 61 PUSH2 0x2000 [0x2000, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 038D 60 PUSH1 0x40 [0x40, 0x2000, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 038F 51 MLOAD [M_A0, 0x2000, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // M_A0 := memory@0x40 | |
| 0390 90 SWAP1 [0x2000, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0391 81 DUP2 [M_A0, 0x2000, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0392 01 ADD [M_B0, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // M_B0 := M_A0 + 0x2000 | |
| 0393 60 PUSH1 0x40 [0x40, M_B0, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0395 52 MSTORE [M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@0x40 := M_B0 | |
| // Writes 256 words into memory | |
| 0396 80 DUP1 [M_A0, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0397 60 PUSH1 0x63 | |
| 0399 60 PUSH1 0xff | |
| 039B 16 AND [0x63, M_A0, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 039C 81 DUP2 [M_A0, 0x63, M_A0, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 039D 52 MSTORE [M_A0, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@M_A0 := 0x00..0063 | |
| 039E 60 PUSH1 0x20 [0x20, M_A0, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 03A0 01 ADD [M_A1, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 03A1 60 PUSH1 0x7c | |
| 03A3 60 PUSH1 0xff | |
| 03A5 16 AND [0x7c, M_A1, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 03A6 81 DUP2 [M_A1, 0x7c, M_A1, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 03A7 52 MSTORE [M_A1, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] // memory@M_A1 := 0x00..007c | |
| 03A8 60 PUSH1 0x20 | |
| 03AA 01 ADD | |
| 03AB 60 PUSH1 0x77 | |
| 03AD 60 PUSH1 0xff | |
| 03AF 16 AND | |
| 03B0 81 DUP2 | |
| 03B1 52 MSTORE | |
| 03B2 60 PUSH1 0x20 | |
| 03B4 01 ADD | |
| 03B5 60 PUSH1 0x7b | |
| 03B7 60 PUSH1 0xff | |
| 03B9 16 AND | |
| 03BA 81 DUP2 | |
| 03BB 52 MSTORE | |
| 03BC 60 PUSH1 0x20 | |
| 03BE 01 ADD | |
| 03BF 60 PUSH1 0xf2 | |
| 03C1 60 PUSH1 0xff | |
| 03C3 16 AND | |
| 03C4 81 DUP2 | |
| 03C5 52 MSTORE | |
| 03C6 60 PUSH1 0x20 | |
| 03C8 01 ADD | |
| 03C9 60 PUSH1 0x6b | |
| 03CB 60 PUSH1 0xff | |
| 03CD 16 AND | |
| 03CE 81 DUP2 | |
| 03CF 52 MSTORE | |
| 03D0 60 PUSH1 0x20 | |
| 03D2 01 ADD | |
| 03D3 60 PUSH1 0x6f | |
| 03D5 60 PUSH1 0xff | |
| 03D7 16 AND | |
| 03D8 81 DUP2 | |
| 03D9 52 MSTORE | |
| 03DA 60 PUSH1 0x20 | |
| 03DC 01 ADD | |
| 03DD 60 PUSH1 0xc5 | |
| 03DF 60 PUSH1 0xff | |
| 03E1 16 AND | |
| 03E2 81 DUP2 | |
| 03E3 52 MSTORE | |
| 03E4 60 PUSH1 0x20 | |
| 03E6 01 ADD | |
| 03E7 60 PUSH1 0x30 | |
| 03E9 60 PUSH1 0xff | |
| 03EB 16 AND | |
| 03EC 81 DUP2 | |
| 03ED 52 MSTORE | |
| 03EE 60 PUSH1 0x20 | |
| 03F0 01 ADD | |
| 03F1 60 PUSH1 0x01 | |
| 03F3 60 PUSH1 0xff | |
| 03F5 16 AND | |
| 03F6 81 DUP2 | |
| 03F7 52 MSTORE | |
| 03F8 60 PUSH1 0x20 | |
| 03FA 01 ADD | |
| 03FB 60 PUSH1 0x67 | |
| 03FD 60 PUSH1 0xff | |
| 03FF 16 AND | |
| 0400 81 DUP2 | |
| 0401 52 MSTORE | |
| 0402 60 PUSH1 0x20 | |
| 0404 01 ADD | |
| 0405 60 PUSH1 0x2b | |
| 0407 60 PUSH1 0xff | |
| 0409 16 AND | |
| 040A 81 DUP2 | |
| 040B 52 MSTORE | |
| 040C 60 PUSH1 0x20 | |
| 040E 01 ADD | |
| 040F 60 PUSH1 0xfe | |
| 0411 60 PUSH1 0xff | |
| 0413 16 AND | |
| 0414 81 DUP2 | |
| 0415 52 MSTORE | |
| 0416 60 PUSH1 0x20 | |
| 0418 01 ADD | |
| 0419 60 PUSH1 0xd7 | |
| 041B 60 PUSH1 0xff | |
| 041D 16 AND | |
| 041E 81 DUP2 | |
| 041F 52 MSTORE | |
| 0420 60 PUSH1 0x20 | |
| 0422 01 ADD | |
| 0423 60 PUSH1 0xab | |
| 0425 60 PUSH1 0xff | |
| 0427 16 AND | |
| 0428 81 DUP2 | |
| 0429 52 MSTORE | |
| 042A 60 PUSH1 0x20 | |
| 042C 01 ADD | |
| 042D 60 PUSH1 0x76 | |
| 042F 60 PUSH1 0xff | |
| 0431 16 AND | |
| 0432 81 DUP2 | |
| 0433 52 MSTORE | |
| 0434 60 PUSH1 0x20 | |
| 0436 01 ADD | |
| 0437 60 PUSH1 0xca | |
| 0439 60 PUSH1 0xff | |
| 043B 16 AND | |
| 043C 81 DUP2 | |
| 043D 52 MSTORE | |
| 043E 60 PUSH1 0x20 | |
| 0440 01 ADD | |
| 0441 60 PUSH1 0x82 | |
| 0443 60 PUSH1 0xff | |
| 0445 16 AND | |
| 0446 81 DUP2 | |
| 0447 52 MSTORE | |
| 0448 60 PUSH1 0x20 | |
| 044A 01 ADD | |
| 044B 60 PUSH1 0xc9 | |
| 044D 60 PUSH1 0xff | |
| 044F 16 AND | |
| 0450 81 DUP2 | |
| 0451 52 MSTORE | |
| 0452 60 PUSH1 0x20 | |
| 0454 01 ADD | |
| 0455 60 PUSH1 0x7d | |
| 0457 60 PUSH1 0xff | |
| 0459 16 AND | |
| 045A 81 DUP2 | |
| 045B 52 MSTORE | |
| 045C 60 PUSH1 0x20 | |
| 045E 01 ADD | |
| 045F 60 PUSH1 0xfa | |
| 0461 60 PUSH1 0xff | |
| 0463 16 AND | |
| 0464 81 DUP2 | |
| 0465 52 MSTORE | |
| 0466 60 PUSH1 0x20 | |
| 0468 01 ADD | |
| 0469 60 PUSH1 0x59 | |
| 046B 60 PUSH1 0xff | |
| 046D 16 AND | |
| 046E 81 DUP2 | |
| 046F 52 MSTORE | |
| 0470 60 PUSH1 0x20 | |
| 0472 01 ADD | |
| 0473 60 PUSH1 0x47 | |
| 0475 60 PUSH1 0xff | |
| 0477 16 AND | |
| 0478 81 DUP2 | |
| 0479 52 MSTORE | |
| 047A 60 PUSH1 0x20 | |
| 047C 01 ADD | |
| 047D 60 PUSH1 0xf0 | |
| 047F 60 PUSH1 0xff | |
| 0481 16 AND | |
| 0482 81 DUP2 | |
| 0483 52 MSTORE | |
| 0484 60 PUSH1 0x20 | |
| 0486 01 ADD | |
| 0487 60 PUSH1 0xad | |
| 0489 60 PUSH1 0xff | |
| 048B 16 AND | |
| 048C 81 DUP2 | |
| 048D 52 MSTORE | |
| 048E 60 PUSH1 0x20 | |
| 0490 01 ADD | |
| 0491 60 PUSH1 0xd4 | |
| 0493 60 PUSH1 0xff | |
| 0495 16 AND | |
| 0496 81 DUP2 | |
| 0497 52 MSTORE | |
| 0498 60 PUSH1 0x20 | |
| 049A 01 ADD | |
| 049B 60 PUSH1 0xa2 | |
| 049D 60 PUSH1 0xff | |
| 049F 16 AND | |
| 04A0 81 DUP2 | |
| 04A1 52 MSTORE | |
| 04A2 60 PUSH1 0x20 | |
| 04A4 01 ADD | |
| 04A5 60 PUSH1 0xaf | |
| 04A7 60 PUSH1 0xff | |
| 04A9 16 AND | |
| 04AA 81 DUP2 | |
| 04AB 52 MSTORE | |
| 04AC 60 PUSH1 0x20 | |
| 04AE 01 ADD | |
| 04AF 60 PUSH1 0x9c | |
| 04B1 60 PUSH1 0xff | |
| 04B3 16 AND | |
| 04B4 81 DUP2 | |
| 04B5 52 MSTORE | |
| 04B6 60 PUSH1 0x20 | |
| 04B8 01 ADD | |
| 04B9 60 PUSH1 0xa4 | |
| 04BB 60 PUSH1 0xff | |
| 04BD 16 AND | |
| 04BE 81 DUP2 | |
| 04BF 52 MSTORE | |
| 04C0 60 PUSH1 0x20 | |
| 04C2 01 ADD | |
| 04C3 60 PUSH1 0x72 | |
| 04C5 60 PUSH1 0xff | |
| 04C7 16 AND | |
| 04C8 81 DUP2 | |
| 04C9 52 MSTORE | |
| 04CA 60 PUSH1 0x20 | |
| 04CC 01 ADD | |
| 04CD 60 PUSH1 0xc0 | |
| 04CF 60 PUSH1 0xff | |
| 04D1 16 AND | |
| 04D2 81 DUP2 | |
| 04D3 52 MSTORE | |
| 04D4 60 PUSH1 0x20 | |
| 04D6 01 ADD | |
| 04D7 60 PUSH1 0xb7 | |
| 04D9 60 PUSH1 0xff | |
| 04DB 16 AND | |
| 04DC 81 DUP2 | |
| 04DD 52 MSTORE | |
| 04DE 60 PUSH1 0x20 | |
| 04E0 01 ADD | |
| 04E1 60 PUSH1 0xfd | |
| 04E3 60 PUSH1 0xff | |
| 04E5 16 AND | |
| 04E6 81 DUP2 | |
| 04E7 52 MSTORE | |
| 04E8 60 PUSH1 0x20 | |
| 04EA 01 ADD | |
| 04EB 60 PUSH1 0x93 | |
| 04ED 60 PUSH1 0xff | |
| 04EF 16 AND | |
| 04F0 81 DUP2 | |
| 04F1 52 MSTORE | |
| 04F2 60 PUSH1 0x20 | |
| 04F4 01 ADD | |
| 04F5 60 PUSH1 0x26 | |
| 04F7 60 PUSH1 0xff | |
| 04F9 16 AND | |
| 04FA 81 DUP2 | |
| 04FB 52 MSTORE | |
| 04FC 60 PUSH1 0x20 | |
| 04FE 01 ADD | |
| 04FF 60 PUSH1 0x36 | |
| 0501 60 PUSH1 0xff | |
| 0503 16 AND | |
| 0504 81 DUP2 | |
| 0505 52 MSTORE | |
| 0506 60 PUSH1 0x20 | |
| 0508 01 ADD | |
| 0509 60 PUSH1 0x3f | |
| 050B 60 PUSH1 0xff | |
| 050D 16 AND | |
| 050E 81 DUP2 | |
| 050F 52 MSTORE | |
| 0510 60 PUSH1 0x20 | |
| 0512 01 ADD | |
| 0513 60 PUSH1 0xf7 | |
| 0515 60 PUSH1 0xff | |
| 0517 16 AND | |
| 0518 81 DUP2 | |
| 0519 52 MSTORE | |
| 051A 60 PUSH1 0x20 | |
| 051C 01 ADD | |
| 051D 60 PUSH1 0xcc | |
| 051F 60 PUSH1 0xff | |
| 0521 16 AND | |
| 0522 81 DUP2 | |
| 0523 52 MSTORE | |
| 0524 60 PUSH1 0x20 | |
| 0526 01 ADD | |
| 0527 60 PUSH1 0x34 | |
| 0529 60 PUSH1 0xff | |
| 052B 16 AND | |
| 052C 81 DUP2 | |
| 052D 52 MSTORE | |
| 052E 60 PUSH1 0x20 | |
| 0530 01 ADD | |
| 0531 60 PUSH1 0xa5 | |
| 0533 60 PUSH1 0xff | |
| 0535 16 AND | |
| 0536 81 DUP2 | |
| 0537 52 MSTORE | |
| 0538 60 PUSH1 0x20 | |
| 053A 01 ADD | |
| 053B 60 PUSH1 0xe5 | |
| 053D 60 PUSH1 0xff | |
| 053F 16 AND | |
| 0540 81 DUP2 | |
| 0541 52 MSTORE | |
| 0542 60 PUSH1 0x20 | |
| 0544 01 ADD | |
| 0545 60 PUSH1 0xf1 | |
| 0547 60 PUSH1 0xff | |
| 0549 16 AND | |
| 054A 81 DUP2 | |
| 054B 52 MSTORE | |
| 054C 60 PUSH1 0x20 | |
| 054E 01 ADD | |
| 054F 60 PUSH1 0x71 | |
| 0551 60 PUSH1 0xff | |
| 0553 16 AND | |
| 0554 81 DUP2 | |
| 0555 52 MSTORE | |
| 0556 60 PUSH1 0x20 | |
| 0558 01 ADD | |
| 0559 60 PUSH1 0xd8 | |
| 055B 60 PUSH1 0xff | |
| 055D 16 AND | |
| 055E 81 DUP2 | |
| 055F 52 MSTORE | |
| 0560 60 PUSH1 0x20 | |
| 0562 01 ADD | |
| 0563 60 PUSH1 0x31 | |
| 0565 60 PUSH1 0xff | |
| 0567 16 AND | |
| 0568 81 DUP2 | |
| 0569 52 MSTORE | |
| 056A 60 PUSH1 0x20 | |
| 056C 01 ADD | |
| 056D 60 PUSH1 0x15 | |
| 056F 60 PUSH1 0xff | |
| 0571 16 AND | |
| 0572 81 DUP2 | |
| 0573 52 MSTORE | |
| 0574 60 PUSH1 0x20 | |
| 0576 01 ADD | |
| 0577 60 PUSH1 0x04 | |
| 0579 60 PUSH1 0xff | |
| 057B 16 AND | |
| 057C 81 DUP2 | |
| 057D 52 MSTORE | |
| 057E 60 PUSH1 0x20 | |
| 0580 01 ADD | |
| 0581 60 PUSH1 0xc7 | |
| 0583 60 PUSH1 0xff | |
| 0585 16 AND | |
| 0586 81 DUP2 | |
| 0587 52 MSTORE | |
| 0588 60 PUSH1 0x20 | |
| 058A 01 ADD | |
| 058B 60 PUSH1 0x23 | |
| 058D 60 PUSH1 0xff | |
| 058F 16 AND | |
| 0590 81 DUP2 | |
| 0591 52 MSTORE | |
| 0592 60 PUSH1 0x20 | |
| 0594 01 ADD | |
| 0595 60 PUSH1 0xc3 | |
| 0597 60 PUSH1 0xff | |
| 0599 16 AND | |
| 059A 81 DUP2 | |
| 059B 52 MSTORE | |
| 059C 60 PUSH1 0x20 | |
| 059E 01 ADD | |
| 059F 60 PUSH1 0x18 | |
| 05A1 60 PUSH1 0xff | |
| 05A3 16 AND | |
| 05A4 81 DUP2 | |
| 05A5 52 MSTORE | |
| 05A6 60 PUSH1 0x20 | |
| 05A8 01 ADD | |
| 05A9 60 PUSH1 0x96 | |
| 05AB 60 PUSH1 0xff | |
| 05AD 16 AND | |
| 05AE 81 DUP2 | |
| 05AF 52 MSTORE | |
| 05B0 60 PUSH1 0x20 | |
| 05B2 01 ADD | |
| 05B3 60 PUSH1 0x05 | |
| 05B5 60 PUSH1 0xff | |
| 05B7 16 AND | |
| 05B8 81 DUP2 | |
| 05B9 52 MSTORE | |
| 05BA 60 PUSH1 0x20 | |
| 05BC 01 ADD | |
| 05BD 60 PUSH1 0x9a | |
| 05BF 60 PUSH1 0xff | |
| 05C1 16 AND | |
| 05C2 81 DUP2 | |
| 05C3 52 MSTORE | |
| 05C4 60 PUSH1 0x20 | |
| 05C6 01 ADD | |
| 05C7 60 PUSH1 0x07 | |
| 05C9 60 PUSH1 0xff | |
| 05CB 16 AND | |
| 05CC 81 DUP2 | |
| 05CD 52 MSTORE | |
| 05CE 60 PUSH1 0x20 | |
| 05D0 01 ADD | |
| 05D1 60 PUSH1 0x12 | |
| 05D3 60 PUSH1 0xff | |
| 05D5 16 AND | |
| 05D6 81 DUP2 | |
| 05D7 52 MSTORE | |
| 05D8 60 PUSH1 0x20 | |
| 05DA 01 ADD | |
| 05DB 60 PUSH1 0x80 | |
| 05DD 60 PUSH1 0xff | |
| 05DF 16 AND | |
| 05E0 81 DUP2 | |
| 05E1 52 MSTORE | |
| 05E2 60 PUSH1 0x20 | |
| 05E4 01 ADD | |
| 05E5 60 PUSH1 0xe2 | |
| 05E7 60 PUSH1 0xff | |
| 05E9 16 AND | |
| 05EA 81 DUP2 | |
| 05EB 52 MSTORE | |
| 05EC 60 PUSH1 0x20 | |
| 05EE 01 ADD | |
| 05EF 60 PUSH1 0xeb | |
| 05F1 60 PUSH1 0xff | |
| 05F3 16 AND | |
| 05F4 81 DUP2 | |
| 05F5 52 MSTORE | |
| 05F6 60 PUSH1 0x20 | |
| 05F8 01 ADD | |
| 05F9 60 PUSH1 0x27 | |
| 05FB 60 PUSH1 0xff | |
| 05FD 16 AND | |
| 05FE 81 DUP2 | |
| 05FF 52 MSTORE | |
| 0600 60 PUSH1 0x20 | |
| 0602 01 ADD | |
| 0603 60 PUSH1 0xb2 | |
| 0605 60 PUSH1 0xff | |
| 0607 16 AND | |
| 0608 81 DUP2 | |
| 0609 52 MSTORE | |
| 060A 60 PUSH1 0x20 | |
| 060C 01 ADD | |
| 060D 60 PUSH1 0x75 | |
| 060F 60 PUSH1 0xff | |
| 0611 16 AND | |
| 0612 81 DUP2 | |
| 0613 52 MSTORE | |
| 0614 60 PUSH1 0x20 | |
| 0616 01 ADD | |
| 0617 60 PUSH1 0x09 | |
| 0619 60 PUSH1 0xff | |
| 061B 16 AND | |
| 061C 81 DUP2 | |
| 061D 52 MSTORE | |
| 061E 60 PUSH1 0x20 | |
| 0620 01 ADD | |
| 0621 60 PUSH1 0x83 | |
| 0623 60 PUSH1 0xff | |
| 0625 16 AND | |
| 0626 81 DUP2 | |
| 0627 52 MSTORE | |
| 0628 60 PUSH1 0x20 | |
| 062A 01 ADD | |
| 062B 60 PUSH1 0x2c | |
| 062D 60 PUSH1 0xff | |
| 062F 16 AND | |
| 0630 81 DUP2 | |
| 0631 52 MSTORE | |
| 0632 60 PUSH1 0x20 | |
| 0634 01 ADD | |
| 0635 60 PUSH1 0x1a | |
| 0637 60 PUSH1 0xff | |
| 0639 16 AND | |
| 063A 81 DUP2 | |
| 063B 52 MSTORE | |
| 063C 60 PUSH1 0x20 | |
| 063E 01 ADD | |
| 063F 60 PUSH1 0x1b | |
| 0641 60 PUSH1 0xff | |
| 0643 16 AND | |
| 0644 81 DUP2 | |
| 0645 52 MSTORE | |
| 0646 60 PUSH1 0x20 | |
| 0648 01 ADD | |
| 0649 60 PUSH1 0x6e | |
| 064B 60 PUSH1 0xff | |
| 064D 16 AND | |
| 064E 81 DUP2 | |
| 064F 52 MSTORE | |
| 0650 60 PUSH1 0x20 | |
| 0652 01 ADD | |
| 0653 60 PUSH1 0x5a | |
| 0655 60 PUSH1 0xff | |
| 0657 16 AND | |
| 0658 81 DUP2 | |
| 0659 52 MSTORE | |
| 065A 60 PUSH1 0x20 | |
| 065C 01 ADD | |
| 065D 60 PUSH1 0xa0 | |
| 065F 60 PUSH1 0xff | |
| 0661 16 AND | |
| 0662 81 DUP2 | |
| 0663 52 MSTORE | |
| 0664 60 PUSH1 0x20 | |
| 0666 01 ADD | |
| 0667 60 PUSH1 0x52 | |
| 0669 60 PUSH1 0xff | |
| 066B 16 AND | |
| 066C 81 DUP2 | |
| 066D 52 MSTORE | |
| 066E 60 PUSH1 0x20 | |
| 0670 01 ADD | |
| 0671 60 PUSH1 0x3b | |
| 0673 60 PUSH1 0xff | |
| 0675 16 AND | |
| 0676 81 DUP2 | |
| 0677 52 MSTORE | |
| 0678 60 PUSH1 0x20 | |
| 067A 01 ADD | |
| 067B 60 PUSH1 0xd6 | |
| 067D 60 PUSH1 0xff | |
| 067F 16 AND | |
| 0680 81 DUP2 | |
| 0681 52 MSTORE | |
| 0682 60 PUSH1 0x20 | |
| 0684 01 ADD | |
| 0685 60 PUSH1 0xb3 | |
| 0687 60 PUSH1 0xff | |
| 0689 16 AND | |
| 068A 81 DUP2 | |
| 068B 52 MSTORE | |
| 068C 60 PUSH1 0x20 | |
| 068E 01 ADD | |
| 068F 60 PUSH1 0x29 | |
| 0691 60 PUSH1 0xff | |
| 0693 16 AND | |
| 0694 81 DUP2 | |
| 0695 52 MSTORE | |
| 0696 60 PUSH1 0x20 | |
| 0698 01 ADD | |
| 0699 60 PUSH1 0xe3 | |
| 069B 60 PUSH1 0xff | |
| 069D 16 AND | |
| 069E 81 DUP2 | |
| 069F 52 MSTORE | |
| 06A0 60 PUSH1 0x20 | |
| 06A2 01 ADD | |
| 06A3 60 PUSH1 0x2f | |
| 06A5 60 PUSH1 0xff | |
| 06A7 16 AND | |
| 06A8 81 DUP2 | |
| 06A9 52 MSTORE | |
| 06AA 60 PUSH1 0x20 | |
| 06AC 01 ADD | |
| 06AD 60 PUSH1 0x84 | |
| 06AF 60 PUSH1 0xff | |
| 06B1 16 AND | |
| 06B2 81 DUP2 | |
| 06B3 52 MSTORE | |
| 06B4 60 PUSH1 0x20 | |
| 06B6 01 ADD | |
| 06B7 60 PUSH1 0x53 | |
| 06B9 60 PUSH1 0xff | |
| 06BB 16 AND | |
| 06BC 81 DUP2 | |
| 06BD 52 MSTORE | |
| 06BE 60 PUSH1 0x20 | |
| 06C0 01 ADD | |
| 06C1 60 PUSH1 0xd1 | |
| 06C3 60 PUSH1 0xff | |
| 06C5 16 AND | |
| 06C6 81 DUP2 | |
| 06C7 52 MSTORE | |
| 06C8 60 PUSH1 0x20 | |
| 06CA 01 ADD | |
| 06CB 60 PUSH1 0x00 | |
| 06CD 60 PUSH1 0xff | |
| 06CF 16 AND | |
| 06D0 81 DUP2 | |
| 06D1 52 MSTORE | |
| 06D2 60 PUSH1 0x20 | |
| 06D4 01 ADD | |
| 06D5 60 PUSH1 0xed | |
| 06D7 60 PUSH1 0xff | |
| 06D9 16 AND | |
| 06DA 81 DUP2 | |
| 06DB 52 MSTORE | |
| 06DC 60 PUSH1 0x20 | |
| 06DE 01 ADD | |
| 06DF 60 PUSH1 0x20 | |
| 06E1 60 PUSH1 0xff | |
| 06E3 16 AND | |
| 06E4 81 DUP2 | |
| 06E5 52 MSTORE | |
| 06E6 60 PUSH1 0x20 | |
| 06E8 01 ADD | |
| 06E9 60 PUSH1 0xfc | |
| 06EB 60 PUSH1 0xff | |
| 06ED 16 AND | |
| 06EE 81 DUP2 | |
| 06EF 52 MSTORE | |
| 06F0 60 PUSH1 0x20 | |
| 06F2 01 ADD | |
| 06F3 60 PUSH1 0xb1 | |
| 06F5 60 PUSH1 0xff | |
| 06F7 16 AND | |
| 06F8 81 DUP2 | |
| 06F9 52 MSTORE | |
| 06FA 60 PUSH1 0x20 | |
| 06FC 01 ADD | |
| 06FD 60 PUSH1 0x5b | |
| 06FF 60 PUSH1 0xff | |
| 0701 16 AND | |
| 0702 81 DUP2 | |
| 0703 52 MSTORE | |
| 0704 60 PUSH1 0x20 | |
| 0706 01 ADD | |
| 0707 60 PUSH1 0x6a | |
| 0709 60 PUSH1 0xff | |
| 070B 16 AND | |
| 070C 81 DUP2 | |
| 070D 52 MSTORE | |
| 070E 60 PUSH1 0x20 | |
| 0710 01 ADD | |
| 0711 60 PUSH1 0xcb | |
| 0713 60 PUSH1 0xff | |
| 0715 16 AND | |
| 0716 81 DUP2 | |
| 0717 52 MSTORE | |
| 0718 60 PUSH1 0x20 | |
| 071A 01 ADD | |
| 071B 60 PUSH1 0xbe | |
| 071D 60 PUSH1 0xff | |
| 071F 16 AND | |
| 0720 81 DUP2 | |
| 0721 52 MSTORE | |
| 0722 60 PUSH1 0x20 | |
| 0724 01 ADD | |
| 0725 60 PUSH1 0x39 | |
| 0727 60 PUSH1 0xff | |
| 0729 16 AND | |
| 072A 81 DUP2 | |
| 072B 52 MSTORE | |
| 072C 60 PUSH1 0x20 | |
| 072E 01 ADD | |
| 072F 60 PUSH1 0x4a | |
| 0731 60 PUSH1 0xff | |
| 0733 16 AND | |
| 0734 81 DUP2 | |
| 0735 52 MSTORE | |
| 0736 60 PUSH1 0x20 | |
| 0738 01 ADD | |
| 0739 60 PUSH1 0x4c | |
| 073B 60 PUSH1 0xff | |
| 073D 16 AND | |
| 073E 81 DUP2 | |
| 073F 52 MSTORE | |
| 0740 60 PUSH1 0x20 | |
| 0742 01 ADD | |
| 0743 60 PUSH1 0x58 | |
| 0745 60 PUSH1 0xff | |
| 0747 16 AND | |
| 0748 81 DUP2 | |
| 0749 52 MSTORE | |
| 074A 60 PUSH1 0x20 | |
| 074C 01 ADD | |
| 074D 60 PUSH1 0xcf | |
| 074F 60 PUSH1 0xff | |
| 0751 16 AND | |
| 0752 81 DUP2 | |
| 0753 52 MSTORE | |
| 0754 60 PUSH1 0x20 | |
| 0756 01 ADD | |
| 0757 60 PUSH1 0xd0 | |
| 0759 60 PUSH1 0xff | |
| 075B 16 AND | |
| 075C 81 DUP2 | |
| 075D 52 MSTORE | |
| 075E 60 PUSH1 0x20 | |
| 0760 01 ADD | |
| 0761 60 PUSH1 0xef | |
| 0763 60 PUSH1 0xff | |
| 0765 16 AND | |
| 0766 81 DUP2 | |
| 0767 52 MSTORE | |
| 0768 60 PUSH1 0x20 | |
| 076A 01 ADD | |
| 076B 60 PUSH1 0xaa | |
| 076D 60 PUSH1 0xff | |
| 076F 16 AND | |
| 0770 81 DUP2 | |
| 0771 52 MSTORE | |
| 0772 60 PUSH1 0x20 | |
| 0774 01 ADD | |
| 0775 60 PUSH1 0xfb | |
| 0777 60 PUSH1 0xff | |
| 0779 16 AND | |
| 077A 81 DUP2 | |
| 077B 52 MSTORE | |
| 077C 60 PUSH1 0x20 | |
| 077E 01 ADD | |
| 077F 60 PUSH1 0x43 | |
| 0781 60 PUSH1 0xff | |
| 0783 16 AND | |
| 0784 81 DUP2 | |
| 0785 52 MSTORE | |
| 0786 60 PUSH1 0x20 | |
| 0788 01 ADD | |
| 0789 60 PUSH1 0x4d | |
| 078B 60 PUSH1 0xff | |
| 078D 16 AND | |
| 078E 81 DUP2 | |
| 078F 52 MSTORE | |
| 0790 60 PUSH1 0x20 | |
| 0792 01 ADD | |
| 0793 60 PUSH1 0x33 | |
| 0795 60 PUSH1 0xff | |
| 0797 16 AND | |
| 0798 81 DUP2 | |
| 0799 52 MSTORE | |
| 079A 60 PUSH1 0x20 | |
| 079C 01 ADD | |
| 079D 60 PUSH1 0x85 | |
| 079F 60 PUSH1 0xff | |
| 07A1 16 AND | |
| 07A2 81 DUP2 | |
| 07A3 52 MSTORE | |
| 07A4 60 PUSH1 0x20 | |
| 07A6 01 ADD | |
| 07A7 60 PUSH1 0x45 | |
| 07A9 60 PUSH1 0xff | |
| 07AB 16 AND | |
| 07AC 81 DUP2 | |
| 07AD 52 MSTORE | |
| 07AE 60 PUSH1 0x20 | |
| 07B0 01 ADD | |
| 07B1 60 PUSH1 0xf9 | |
| 07B3 60 PUSH1 0xff | |
| 07B5 16 AND | |
| 07B6 81 DUP2 | |
| 07B7 52 MSTORE | |
| 07B8 60 PUSH1 0x20 | |
| 07BA 01 ADD | |
| 07BB 60 PUSH1 0x02 | |
| 07BD 60 PUSH1 0xff | |
| 07BF 16 AND | |
| 07C0 81 DUP2 | |
| 07C1 52 MSTORE | |
| 07C2 60 PUSH1 0x20 | |
| 07C4 01 ADD | |
| 07C5 60 PUSH1 0x7f | |
| 07C7 60 PUSH1 0xff | |
| 07C9 16 AND | |
| 07CA 81 DUP2 | |
| 07CB 52 MSTORE | |
| 07CC 60 PUSH1 0x20 | |
| 07CE 01 ADD | |
| 07CF 60 PUSH1 0x50 | |
| 07D1 60 PUSH1 0xff | |
| 07D3 16 AND | |
| 07D4 81 DUP2 | |
| 07D5 52 MSTORE | |
| 07D6 60 PUSH1 0x20 | |
| 07D8 01 ADD | |
| 07D9 60 PUSH1 0x3c | |
| 07DB 60 PUSH1 0xff | |
| 07DD 16 AND | |
| 07DE 81 DUP2 | |
| 07DF 52 MSTORE | |
| 07E0 60 PUSH1 0x20 | |
| 07E2 01 ADD | |
| 07E3 60 PUSH1 0x9f | |
| 07E5 60 PUSH1 0xff | |
| 07E7 16 AND | |
| 07E8 81 DUP2 | |
| 07E9 52 MSTORE | |
| 07EA 60 PUSH1 0x20 | |
| 07EC 01 ADD | |
| 07ED 60 PUSH1 0xa8 | |
| 07EF 60 PUSH1 0xff | |
| 07F1 16 AND | |
| 07F2 81 DUP2 | |
| 07F3 52 MSTORE | |
| 07F4 60 PUSH1 0x20 | |
| 07F6 01 ADD | |
| 07F7 60 PUSH1 0x51 | |
| 07F9 60 PUSH1 0xff | |
| 07FB 16 AND | |
| 07FC 81 DUP2 | |
| 07FD 52 MSTORE | |
| 07FE 60 PUSH1 0x20 | |
| 0800 01 ADD | |
| 0801 60 PUSH1 0xa3 | |
| 0803 60 PUSH1 0xff | |
| 0805 16 AND | |
| 0806 81 DUP2 | |
| 0807 52 MSTORE | |
| 0808 60 PUSH1 0x20 | |
| 080A 01 ADD | |
| 080B 60 PUSH1 0x40 | |
| 080D 60 PUSH1 0xff | |
| 080F 16 AND | |
| 0810 81 DUP2 | |
| 0811 52 MSTORE | |
| 0812 60 PUSH1 0x20 | |
| 0814 01 ADD | |
| 0815 60 PUSH1 0x8f | |
| 0817 60 PUSH1 0xff | |
| 0819 16 AND | |
| 081A 81 DUP2 | |
| 081B 52 MSTORE | |
| 081C 60 PUSH1 0x20 | |
| 081E 01 ADD | |
| 081F 60 PUSH1 0x92 | |
| 0821 60 PUSH1 0xff | |
| 0823 16 AND | |
| 0824 81 DUP2 | |
| 0825 52 MSTORE | |
| 0826 60 PUSH1 0x20 | |
| 0828 01 ADD | |
| 0829 60 PUSH1 0x9d | |
| 082B 60 PUSH1 0xff | |
| 082D 16 AND | |
| 082E 81 DUP2 | |
| 082F 52 MSTORE | |
| 0830 60 PUSH1 0x20 | |
| 0832 01 ADD | |
| 0833 60 PUSH1 0x38 | |
| 0835 60 PUSH1 0xff | |
| 0837 16 AND | |
| 0838 81 DUP2 | |
| 0839 52 MSTORE | |
| 083A 60 PUSH1 0x20 | |
| 083C 01 ADD | |
| 083D 60 PUSH1 0xf5 | |
| 083F 60 PUSH1 0xff | |
| 0841 16 AND | |
| 0842 81 DUP2 | |
| 0843 52 MSTORE | |
| 0844 60 PUSH1 0x20 | |
| 0846 01 ADD | |
| 0847 60 PUSH1 0xbc | |
| 0849 60 PUSH1 0xff | |
| 084B 16 AND | |
| 084C 81 DUP2 | |
| 084D 52 MSTORE | |
| 084E 60 PUSH1 0x20 | |
| 0850 01 ADD | |
| 0851 60 PUSH1 0xb6 | |
| 0853 60 PUSH1 0xff | |
| 0855 16 AND | |
| 0856 81 DUP2 | |
| 0857 52 MSTORE | |
| 0858 60 PUSH1 0x20 | |
| 085A 01 ADD | |
| 085B 60 PUSH1 0xda | |
| 085D 60 PUSH1 0xff | |
| 085F 16 AND | |
| 0860 81 DUP2 | |
| 0861 52 MSTORE | |
| 0862 60 PUSH1 0x20 | |
| 0864 01 ADD | |
| 0865 60 PUSH1 0x21 | |
| 0867 60 PUSH1 0xff | |
| 0869 16 AND | |
| 086A 81 DUP2 | |
| 086B 52 MSTORE | |
| 086C 60 PUSH1 0x20 | |
| 086E 01 ADD | |
| 086F 60 PUSH1 0x10 | |
| 0871 60 PUSH1 0xff | |
| 0873 16 AND | |
| 0874 81 DUP2 | |
| 0875 52 MSTORE | |
| 0876 60 PUSH1 0x20 | |
| 0878 01 ADD | |
| 0879 60 PUSH1 0xff | |
| 087B 80 DUP1 | |
| 087C 16 AND | |
| 087D 81 DUP2 | |
| 087E 52 MSTORE | |
| 087F 60 PUSH1 0x20 | |
| 0881 01 ADD | |
| 0882 60 PUSH1 0xf3 | |
| 0884 60 PUSH1 0xff | |
| 0886 16 AND | |
| 0887 81 DUP2 | |
| 0888 52 MSTORE | |
| 0889 60 PUSH1 0x20 | |
| 088B 01 ADD | |
| 088C 60 PUSH1 0xd2 | |
| 088E 60 PUSH1 0xff | |
| 0890 16 AND | |
| 0891 81 DUP2 | |
| 0892 52 MSTORE | |
| 0893 60 PUSH1 0x20 | |
| 0895 01 ADD | |
| 0896 60 PUSH1 0xcd | |
| 0898 60 PUSH1 0xff | |
| 089A 16 AND | |
| 089B 81 DUP2 | |
| 089C 52 MSTORE | |
| 089D 60 PUSH1 0x20 | |
| 089F 01 ADD | |
| 08A0 60 PUSH1 0x0c | |
| 08A2 60 PUSH1 0xff | |
| 08A4 16 AND | |
| 08A5 81 DUP2 | |
| 08A6 52 MSTORE | |
| 08A7 60 PUSH1 0x20 | |
| 08A9 01 ADD | |
| 08AA 60 PUSH1 0x13 | |
| 08AC 60 PUSH1 0xff | |
| 08AE 16 AND | |
| 08AF 81 DUP2 | |
| 08B0 52 MSTORE | |
| 08B1 60 PUSH1 0x20 | |
| 08B3 01 ADD | |
| 08B4 60 PUSH1 0xec | |
| 08B6 60 PUSH1 0xff | |
| 08B8 16 AND | |
| 08B9 81 DUP2 | |
| 08BA 52 MSTORE | |
| 08BB 60 PUSH1 0x20 | |
| 08BD 01 ADD | |
| 08BE 60 PUSH1 0x5f | |
| 08C0 60 PUSH1 0xff | |
| 08C2 16 AND | |
| 08C3 81 DUP2 | |
| 08C4 52 MSTORE | |
| 08C5 60 PUSH1 0x20 | |
| 08C7 01 ADD | |
| 08C8 60 PUSH1 0x97 | |
| 08CA 60 PUSH1 0xff | |
| 08CC 16 AND | |
| 08CD 81 DUP2 | |
| 08CE 52 MSTORE | |
| 08CF 60 PUSH1 0x20 | |
| 08D1 01 ADD | |
| 08D2 60 PUSH1 0x44 | |
| 08D4 60 PUSH1 0xff | |
| 08D6 16 AND | |
| 08D7 81 DUP2 | |
| 08D8 52 MSTORE | |
| 08D9 60 PUSH1 0x20 | |
| 08DB 01 ADD | |
| 08DC 60 PUSH1 0x17 | |
| 08DE 60 PUSH1 0xff | |
| 08E0 16 AND | |
| 08E1 81 DUP2 | |
| 08E2 52 MSTORE | |
| 08E3 60 PUSH1 0x20 | |
| 08E5 01 ADD | |
| 08E6 60 PUSH1 0xc4 | |
| 08E8 60 PUSH1 0xff | |
| 08EA 16 AND | |
| 08EB 81 DUP2 | |
| 08EC 52 MSTORE | |
| 08ED 60 PUSH1 0x20 | |
| 08EF 01 ADD | |
| 08F0 60 PUSH1 0xa7 | |
| 08F2 60 PUSH1 0xff | |
| 08F4 16 AND | |
| 08F5 81 DUP2 | |
| 08F6 52 MSTORE | |
| 08F7 60 PUSH1 0x20 | |
| 08F9 01 ADD | |
| 08FA 60 PUSH1 0x7e | |
| 08FC 60 PUSH1 0xff | |
| 08FE 16 AND | |
| 08FF 81 DUP2 | |
| 0900 52 MSTORE | |
| 0901 60 PUSH1 0x20 | |
| 0903 01 ADD | |
| 0904 60 PUSH1 0x3d | |
| 0906 60 PUSH1 0xff | |
| 0908 16 AND | |
| 0909 81 DUP2 | |
| 090A 52 MSTORE | |
| 090B 60 PUSH1 0x20 | |
| 090D 01 ADD | |
| 090E 60 PUSH1 0x64 | |
| 0910 60 PUSH1 0xff | |
| 0912 16 AND | |
| 0913 81 DUP2 | |
| 0914 52 MSTORE | |
| 0915 60 PUSH1 0x20 | |
| 0917 01 ADD | |
| 0918 60 PUSH1 0x5d | |
| 091A 60 PUSH1 0xff | |
| 091C 16 AND | |
| 091D 81 DUP2 | |
| 091E 52 MSTORE | |
| 091F 60 PUSH1 0x20 | |
| 0921 01 ADD | |
| 0922 60 PUSH1 0x19 | |
| 0924 60 PUSH1 0xff | |
| 0926 16 AND | |
| 0927 81 DUP2 | |
| 0928 52 MSTORE | |
| 0929 60 PUSH1 0x20 | |
| 092B 01 ADD | |
| 092C 60 PUSH1 0x73 | |
| 092E 60 PUSH1 0xff | |
| 0930 16 AND | |
| 0931 81 DUP2 | |
| 0932 52 MSTORE | |
| 0933 60 PUSH1 0x20 | |
| 0935 01 ADD | |
| 0936 60 PUSH1 0x60 | |
| 0938 60 PUSH1 0xff | |
| 093A 16 AND | |
| 093B 81 DUP2 | |
| 093C 52 MSTORE | |
| 093D 60 PUSH1 0x20 | |
| 093F 01 ADD | |
| 0940 60 PUSH1 0x81 | |
| 0942 60 PUSH1 0xff | |
| 0944 16 AND | |
| 0945 81 DUP2 | |
| 0946 52 MSTORE | |
| 0947 60 PUSH1 0x20 | |
| 0949 01 ADD | |
| 094A 60 PUSH1 0x4f | |
| 094C 60 PUSH1 0xff | |
| 094E 16 AND | |
| 094F 81 DUP2 | |
| 0950 52 MSTORE | |
| 0951 60 PUSH1 0x20 | |
| 0953 01 ADD | |
| 0954 60 PUSH1 0xdc | |
| 0956 60 PUSH1 0xff | |
| 0958 16 AND | |
| 0959 81 DUP2 | |
| 095A 52 MSTORE | |
| 095B 60 PUSH1 0x20 | |
| 095D 01 ADD | |
| 095E 60 PUSH1 0x22 | |
| 0960 60 PUSH1 0xff | |
| 0962 16 AND | |
| 0963 81 DUP2 | |
| 0964 52 MSTORE | |
| 0965 60 PUSH1 0x20 | |
| 0967 01 ADD | |
| 0968 60 PUSH1 0x2a | |
| 096A 60 PUSH1 0xff | |
| 096C 16 AND | |
| 096D 81 DUP2 | |
| 096E 52 MSTORE | |
| 096F 60 PUSH1 0x20 | |
| 0971 01 ADD | |
| 0972 60 PUSH1 0x90 | |
| 0974 60 PUSH1 0xff | |
| 0976 16 AND | |
| 0977 81 DUP2 | |
| 0978 52 MSTORE | |
| 0979 60 PUSH1 0x20 | |
| 097B 01 ADD | |
| 097C 60 PUSH1 0x88 | |
| 097E 60 PUSH1 0xff | |
| 0980 16 AND | |
| 0981 81 DUP2 | |
| 0982 52 MSTORE | |
| 0983 60 PUSH1 0x20 | |
| 0985 01 ADD | |
| 0986 60 PUSH1 0x46 | |
| 0988 60 PUSH1 0xff | |
| 098A 16 AND | |
| 098B 81 DUP2 | |
| 098C 52 MSTORE | |
| 098D 60 PUSH1 0x20 | |
| 098F 01 ADD | |
| 0990 60 PUSH1 0xee | |
| 0992 60 PUSH1 0xff | |
| 0994 16 AND | |
| 0995 81 DUP2 | |
| 0996 52 MSTORE | |
| 0997 60 PUSH1 0x20 | |
| 0999 01 ADD | |
| 099A 60 PUSH1 0xb8 | |
| 099C 60 PUSH1 0xff | |
| 099E 16 AND | |
| 099F 81 DUP2 | |
| 09A0 52 MSTORE | |
| 09A1 60 PUSH1 0x20 | |
| 09A3 01 ADD | |
| 09A4 60 PUSH1 0x14 | |
| 09A6 60 PUSH1 0xff | |
| 09A8 16 AND | |
| 09A9 81 DUP2 | |
| 09AA 52 MSTORE | |
| 09AB 60 PUSH1 0x20 | |
| 09AD 01 ADD | |
| 09AE 60 PUSH1 0xde | |
| 09B0 60 PUSH1 0xff | |
| 09B2 16 AND | |
| 09B3 81 DUP2 | |
| 09B4 52 MSTORE | |
| 09B5 60 PUSH1 0x20 | |
| 09B7 01 ADD | |
| 09B8 60 PUSH1 0x5e | |
| 09BA 60 PUSH1 0xff | |
| 09BC 16 AND | |
| 09BD 81 DUP2 | |
| 09BE 52 MSTORE | |
| 09BF 60 PUSH1 0x20 | |
| 09C1 01 ADD | |
| 09C2 60 PUSH1 0x0b | |
| 09C4 60 PUSH1 0xff | |
| 09C6 16 AND | |
| 09C7 81 DUP2 | |
| 09C8 52 MSTORE | |
| 09C9 60 PUSH1 0x20 | |
| 09CB 01 ADD | |
| 09CC 60 PUSH1 0xdb | |
| 09CE 60 PUSH1 0xff | |
| 09D0 16 AND | |
| 09D1 81 DUP2 | |
| 09D2 52 MSTORE | |
| 09D3 60 PUSH1 0x20 | |
| 09D5 01 ADD | |
| 09D6 60 PUSH1 0xe0 | |
| 09D8 60 PUSH1 0xff | |
| 09DA 16 AND | |
| 09DB 81 DUP2 | |
| 09DC 52 MSTORE | |
| 09DD 60 PUSH1 0x20 | |
| 09DF 01 ADD | |
| 09E0 60 PUSH1 0x32 | |
| 09E2 60 PUSH1 0xff | |
| 09E4 16 AND | |
| 09E5 81 DUP2 | |
| 09E6 52 MSTORE | |
| 09E7 60 PUSH1 0x20 | |
| 09E9 01 ADD | |
| 09EA 60 PUSH1 0x3a | |
| 09EC 60 PUSH1 0xff | |
| 09EE 16 AND | |
| 09EF 81 DUP2 | |
| 09F0 52 MSTORE | |
| 09F1 60 PUSH1 0x20 | |
| 09F3 01 ADD | |
| 09F4 60 PUSH1 0x0a | |
| 09F6 60 PUSH1 0xff | |
| 09F8 16 AND | |
| 09F9 81 DUP2 | |
| 09FA 52 MSTORE | |
| 09FB 60 PUSH1 0x20 | |
| 09FD 01 ADD | |
| 09FE 60 PUSH1 0x49 | |
| 0A00 60 PUSH1 0xff | |
| 0A02 16 AND | |
| 0A03 81 DUP2 | |
| 0A04 52 MSTORE | |
| 0A05 60 PUSH1 0x20 | |
| 0A07 01 ADD | |
| 0A08 60 PUSH1 0x06 | |
| 0A0A 60 PUSH1 0xff | |
| 0A0C 16 AND | |
| 0A0D 81 DUP2 | |
| 0A0E 52 MSTORE | |
| 0A0F 60 PUSH1 0x20 | |
| 0A11 01 ADD | |
| 0A12 60 PUSH1 0x24 | |
| 0A14 60 PUSH1 0xff | |
| 0A16 16 AND | |
| 0A17 81 DUP2 | |
| 0A18 52 MSTORE | |
| 0A19 60 PUSH1 0x20 | |
| 0A1B 01 ADD | |
| 0A1C 60 PUSH1 0x5c | |
| 0A1E 60 PUSH1 0xff | |
| 0A20 16 AND | |
| 0A21 81 DUP2 | |
| 0A22 52 MSTORE | |
| 0A23 60 PUSH1 0x20 | |
| 0A25 01 ADD | |
| 0A26 60 PUSH1 0xc2 | |
| 0A28 60 PUSH1 0xff | |
| 0A2A 16 AND | |
| 0A2B 81 DUP2 | |
| 0A2C 52 MSTORE | |
| 0A2D 60 PUSH1 0x20 | |
| 0A2F 01 ADD | |
| 0A30 60 PUSH1 0xd3 | |
| 0A32 60 PUSH1 0xff | |
| 0A34 16 AND | |
| 0A35 81 DUP2 | |
| 0A36 52 MSTORE | |
| 0A37 60 PUSH1 0x20 | |
| 0A39 01 ADD | |
| 0A3A 60 PUSH1 0xac | |
| 0A3C 60 PUSH1 0xff | |
| 0A3E 16 AND | |
| 0A3F 81 DUP2 | |
| 0A40 52 MSTORE | |
| 0A41 60 PUSH1 0x20 | |
| 0A43 01 ADD | |
| 0A44 60 PUSH1 0x62 | |
| 0A46 60 PUSH1 0xff | |
| 0A48 16 AND | |
| 0A49 81 DUP2 | |
| 0A4A 52 MSTORE | |
| 0A4B 60 PUSH1 0x20 | |
| 0A4D 01 ADD | |
| 0A4E 60 PUSH1 0x91 | |
| 0A50 60 PUSH1 0xff | |
| 0A52 16 AND | |
| 0A53 81 DUP2 | |
| 0A54 52 MSTORE | |
| 0A55 60 PUSH1 0x20 | |
| 0A57 01 ADD | |
| 0A58 60 PUSH1 0x95 | |
| 0A5A 60 PUSH1 0xff | |
| 0A5C 16 AND | |
| 0A5D 81 DUP2 | |
| 0A5E 52 MSTORE | |
| 0A5F 60 PUSH1 0x20 | |
| 0A61 01 ADD | |
| 0A62 60 PUSH1 0xe4 | |
| 0A64 60 PUSH1 0xff | |
| 0A66 16 AND | |
| 0A67 81 DUP2 | |
| 0A68 52 MSTORE | |
| 0A69 60 PUSH1 0x20 | |
| 0A6B 01 ADD | |
| 0A6C 60 PUSH1 0x79 | |
| 0A6E 60 PUSH1 0xff | |
| 0A70 16 AND | |
| 0A71 81 DUP2 | |
| 0A72 52 MSTORE | |
| 0A73 60 PUSH1 0x20 | |
| 0A75 01 ADD | |
| 0A76 60 PUSH1 0xe7 | |
| 0A78 60 PUSH1 0xff | |
| 0A7A 16 AND | |
| 0A7B 81 DUP2 | |
| 0A7C 52 MSTORE | |
| 0A7D 60 PUSH1 0x20 | |
| 0A7F 01 ADD | |
| 0A80 60 PUSH1 0xc8 | |
| 0A82 60 PUSH1 0xff | |
| 0A84 16 AND | |
| 0A85 81 DUP2 | |
| 0A86 52 MSTORE | |
| 0A87 60 PUSH1 0x20 | |
| 0A89 01 ADD | |
| 0A8A 60 PUSH1 0x37 | |
| 0A8C 60 PUSH1 0xff | |
| 0A8E 16 AND | |
| 0A8F 81 DUP2 | |
| 0A90 52 MSTORE | |
| 0A91 60 PUSH1 0x20 | |
| 0A93 01 ADD | |
| 0A94 60 PUSH1 0x6d | |
| 0A96 60 PUSH1 0xff | |
| 0A98 16 AND | |
| 0A99 81 DUP2 | |
| 0A9A 52 MSTORE | |
| 0A9B 60 PUSH1 0x20 | |
| 0A9D 01 ADD | |
| 0A9E 60 PUSH1 0x8d | |
| 0AA0 60 PUSH1 0xff | |
| 0AA2 16 AND | |
| 0AA3 81 DUP2 | |
| 0AA4 52 MSTORE | |
| 0AA5 60 PUSH1 0x20 | |
| 0AA7 01 ADD | |
| 0AA8 60 PUSH1 0xd5 | |
| 0AAA 60 PUSH1 0xff | |
| 0AAC 16 AND | |
| 0AAD 81 DUP2 | |
| 0AAE 52 MSTORE | |
| 0AAF 60 PUSH1 0x20 | |
| 0AB1 01 ADD | |
| 0AB2 60 PUSH1 0x4e | |
| 0AB4 60 PUSH1 0xff | |
| 0AB6 16 AND | |
| 0AB7 81 DUP2 | |
| 0AB8 52 MSTORE | |
| 0AB9 60 PUSH1 0x20 | |
| 0ABB 01 ADD | |
| 0ABC 60 PUSH1 0xa9 | |
| 0ABE 60 PUSH1 0xff | |
| 0AC0 16 AND | |
| 0AC1 81 DUP2 | |
| 0AC2 52 MSTORE | |
| 0AC3 60 PUSH1 0x20 | |
| 0AC5 01 ADD | |
| 0AC6 60 PUSH1 0x6c | |
| 0AC8 60 PUSH1 0xff | |
| 0ACA 16 AND | |
| 0ACB 81 DUP2 | |
| 0ACC 52 MSTORE | |
| 0ACD 60 PUSH1 0x20 | |
| 0ACF 01 ADD | |
| 0AD0 60 PUSH1 0x56 | |
| 0AD2 60 PUSH1 0xff | |
| 0AD4 16 AND | |
| 0AD5 81 DUP2 | |
| 0AD6 52 MSTORE | |
| 0AD7 60 PUSH1 0x20 | |
| 0AD9 01 ADD | |
| 0ADA 60 PUSH1 0xf4 | |
| 0ADC 60 PUSH1 0xff | |
| 0ADE 16 AND | |
| 0ADF 81 DUP2 | |
| 0AE0 52 MSTORE | |
| 0AE1 60 PUSH1 0x20 | |
| 0AE3 01 ADD | |
| 0AE4 60 PUSH1 0xea | |
| 0AE6 60 PUSH1 0xff | |
| 0AE8 16 AND | |
| 0AE9 81 DUP2 | |
| 0AEA 52 MSTORE | |
| 0AEB 60 PUSH1 0x20 | |
| 0AED 01 ADD | |
| 0AEE 60 PUSH1 0x65 | |
| 0AF0 60 PUSH1 0xff | |
| 0AF2 16 AND | |
| 0AF3 81 DUP2 | |
| 0AF4 52 MSTORE | |
| 0AF5 60 PUSH1 0x20 | |
| 0AF7 01 ADD | |
| 0AF8 60 PUSH1 0x7a | |
| 0AFA 60 PUSH1 0xff | |
| 0AFC 16 AND | |
| 0AFD 81 DUP2 | |
| 0AFE 52 MSTORE | |
| 0AFF 60 PUSH1 0x20 | |
| 0B01 01 ADD | |
| 0B02 60 PUSH1 0xae | |
| 0B04 60 PUSH1 0xff | |
| 0B06 16 AND | |
| 0B07 81 DUP2 | |
| 0B08 52 MSTORE | |
| 0B09 60 PUSH1 0x20 | |
| 0B0B 01 ADD | |
| 0B0C 60 PUSH1 0x08 | |
| 0B0E 60 PUSH1 0xff | |
| 0B10 16 AND | |
| 0B11 81 DUP2 | |
| 0B12 52 MSTORE | |
| 0B13 60 PUSH1 0x20 | |
| 0B15 01 ADD | |
| 0B16 60 PUSH1 0xba | |
| 0B18 60 PUSH1 0xff | |
| 0B1A 16 AND | |
| 0B1B 81 DUP2 | |
| 0B1C 52 MSTORE | |
| 0B1D 60 PUSH1 0x20 | |
| 0B1F 01 ADD | |
| 0B20 60 PUSH1 0x78 | |
| 0B22 60 PUSH1 0xff | |
| 0B24 16 AND | |
| 0B25 81 DUP2 | |
| 0B26 52 MSTORE | |
| 0B27 60 PUSH1 0x20 | |
| 0B29 01 ADD | |
| 0B2A 60 PUSH1 0x25 | |
| 0B2C 60 PUSH1 0xff | |
| 0B2E 16 AND | |
| 0B2F 81 DUP2 | |
| 0B30 52 MSTORE | |
| 0B31 60 PUSH1 0x20 | |
| 0B33 01 ADD | |
| 0B34 60 PUSH1 0x2e | |
| 0B36 60 PUSH1 0xff | |
| 0B38 16 AND | |
| 0B39 81 DUP2 | |
| 0B3A 52 MSTORE | |
| 0B3B 60 PUSH1 0x20 | |
| 0B3D 01 ADD | |
| 0B3E 60 PUSH1 0x1c | |
| 0B40 60 PUSH1 0xff | |
| 0B42 16 AND | |
| 0B43 81 DUP2 | |
| 0B44 52 MSTORE | |
| 0B45 60 PUSH1 0x20 | |
| 0B47 01 ADD | |
| 0B48 60 PUSH1 0xa6 | |
| 0B4A 60 PUSH1 0xff | |
| 0B4C 16 AND | |
| 0B4D 81 DUP2 | |
| 0B4E 52 MSTORE | |
| 0B4F 60 PUSH1 0x20 | |
| 0B51 01 ADD | |
| 0B52 60 PUSH1 0xb4 | |
| 0B54 60 PUSH1 0xff | |
| 0B56 16 AND | |
| 0B57 81 DUP2 | |
| 0B58 52 MSTORE | |
| 0B59 60 PUSH1 0x20 | |
| 0B5B 01 ADD | |
| 0B5C 60 PUSH1 0xc6 | |
| 0B5E 60 PUSH1 0xff | |
| 0B60 16 AND | |
| 0B61 81 DUP2 | |
| 0B62 52 MSTORE | |
| 0B63 60 PUSH1 0x20 | |
| 0B65 01 ADD | |
| 0B66 60 PUSH1 0xe8 | |
| 0B68 60 PUSH1 0xff | |
| 0B6A 16 AND | |
| 0B6B 81 DUP2 | |
| 0B6C 52 MSTORE | |
| 0B6D 60 PUSH1 0x20 | |
| 0B6F 01 ADD | |
| 0B70 60 PUSH1 0xdd | |
| 0B72 60 PUSH1 0xff | |
| 0B74 16 AND | |
| 0B75 81 DUP2 | |
| 0B76 52 MSTORE | |
| 0B77 60 PUSH1 0x20 | |
| 0B79 01 ADD | |
| 0B7A 60 PUSH1 0x74 | |
| 0B7C 60 PUSH1 0xff | |
| 0B7E 16 AND | |
| 0B7F 81 DUP2 | |
| 0B80 52 MSTORE | |
| 0B81 60 PUSH1 0x20 | |
| 0B83 01 ADD | |
| 0B84 60 PUSH1 0x1f | |
| 0B86 60 PUSH1 0xff | |
| 0B88 16 AND | |
| 0B89 81 DUP2 | |
| 0B8A 52 MSTORE | |
| 0B8B 60 PUSH1 0x20 | |
| 0B8D 01 ADD | |
| 0B8E 60 PUSH1 0x4b | |
| 0B90 60 PUSH1 0xff | |
| 0B92 16 AND | |
| 0B93 81 DUP2 | |
| 0B94 52 MSTORE | |
| 0B95 60 PUSH1 0x20 | |
| 0B97 01 ADD | |
| 0B98 60 PUSH1 0xbd | |
| 0B9A 60 PUSH1 0xff | |
| 0B9C 16 AND | |
| 0B9D 81 DUP2 | |
| 0B9E 52 MSTORE | |
| 0B9F 60 PUSH1 0x20 | |
| 0BA1 01 ADD | |
| 0BA2 60 PUSH1 0x8b | |
| 0BA4 60 PUSH1 0xff | |
| 0BA6 16 AND | |
| 0BA7 81 DUP2 | |
| 0BA8 52 MSTORE | |
| 0BA9 60 PUSH1 0x20 | |
| 0BAB 01 ADD | |
| 0BAC 60 PUSH1 0x8a | |
| 0BAE 60 PUSH1 0xff | |
| 0BB0 16 AND | |
| 0BB1 81 DUP2 | |
| 0BB2 52 MSTORE | |
| 0BB3 60 PUSH1 0x20 | |
| 0BB5 01 ADD | |
| 0BB6 60 PUSH1 0x70 | |
| 0BB8 60 PUSH1 0xff | |
| 0BBA 16 AND | |
| 0BBB 81 DUP2 | |
| 0BBC 52 MSTORE | |
| 0BBD 60 PUSH1 0x20 | |
| 0BBF 01 ADD | |
| 0BC0 60 PUSH1 0x3e | |
| 0BC2 60 PUSH1 0xff | |
| 0BC4 16 AND | |
| 0BC5 81 DUP2 | |
| 0BC6 52 MSTORE | |
| 0BC7 60 PUSH1 0x20 | |
| 0BC9 01 ADD | |
| 0BCA 60 PUSH1 0xb5 | |
| 0BCC 60 PUSH1 0xff | |
| 0BCE 16 AND | |
| 0BCF 81 DUP2 | |
| 0BD0 52 MSTORE | |
| 0BD1 60 PUSH1 0x20 | |
| 0BD3 01 ADD | |
| 0BD4 60 PUSH1 0x66 | |
| 0BD6 60 PUSH1 0xff | |
| 0BD8 16 AND | |
| 0BD9 81 DUP2 | |
| 0BDA 52 MSTORE | |
| 0BDB 60 PUSH1 0x20 | |
| 0BDD 01 ADD | |
| 0BDE 60 PUSH1 0x48 | |
| 0BE0 60 PUSH1 0xff | |
| 0BE2 16 AND | |
| 0BE3 81 DUP2 | |
| 0BE4 52 MSTORE | |
| 0BE5 60 PUSH1 0x20 | |
| 0BE7 01 ADD | |
| 0BE8 60 PUSH1 0x03 | |
| 0BEA 60 PUSH1 0xff | |
| 0BEC 16 AND | |
| 0BED 81 DUP2 | |
| 0BEE 52 MSTORE | |
| 0BEF 60 PUSH1 0x20 | |
| 0BF1 01 ADD | |
| 0BF2 60 PUSH1 0xf6 | |
| 0BF4 60 PUSH1 0xff | |
| 0BF6 16 AND | |
| 0BF7 81 DUP2 | |
| 0BF8 52 MSTORE | |
| 0BF9 60 PUSH1 0x20 | |
| 0BFB 01 ADD | |
| 0BFC 60 PUSH1 0x0e | |
| 0BFE 60 PUSH1 0xff | |
| 0C00 16 AND | |
| 0C01 81 DUP2 | |
| 0C02 52 MSTORE | |
| 0C03 60 PUSH1 0x20 | |
| 0C05 01 ADD | |
| 0C06 60 PUSH1 0x61 | |
| 0C08 60 PUSH1 0xff | |
| 0C0A 16 AND | |
| 0C0B 81 DUP2 | |
| 0C0C 52 MSTORE | |
| 0C0D 60 PUSH1 0x20 | |
| 0C0F 01 ADD | |
| 0C10 60 PUSH1 0x35 | |
| 0C12 60 PUSH1 0xff | |
| 0C14 16 AND | |
| 0C15 81 DUP2 | |
| 0C16 52 MSTORE | |
| 0C17 60 PUSH1 0x20 | |
| 0C19 01 ADD | |
| 0C1A 60 PUSH1 0x57 | |
| 0C1C 60 PUSH1 0xff | |
| 0C1E 16 AND | |
| 0C1F 81 DUP2 | |
| 0C20 52 MSTORE | |
| 0C21 60 PUSH1 0x20 | |
| 0C23 01 ADD | |
| 0C24 60 PUSH1 0xb9 | |
| 0C26 60 PUSH1 0xff | |
| 0C28 16 AND | |
| 0C29 81 DUP2 | |
| 0C2A 52 MSTORE | |
| 0C2B 60 PUSH1 0x20 | |
| 0C2D 01 ADD | |
| 0C2E 60 PUSH1 0x86 | |
| 0C30 60 PUSH1 0xff | |
| 0C32 16 AND | |
| 0C33 81 DUP2 | |
| 0C34 52 MSTORE | |
| 0C35 60 PUSH1 0x20 | |
| 0C37 01 ADD | |
| 0C38 60 PUSH1 0xc1 | |
| 0C3A 60 PUSH1 0xff | |
| 0C3C 16 AND | |
| 0C3D 81 DUP2 | |
| 0C3E 52 MSTORE | |
| 0C3F 60 PUSH1 0x20 | |
| 0C41 01 ADD | |
| 0C42 60 PUSH1 0x1d | |
| 0C44 60 PUSH1 0xff | |
| 0C46 16 AND | |
| 0C47 81 DUP2 | |
| 0C48 52 MSTORE | |
| 0C49 60 PUSH1 0x20 | |
| 0C4B 01 ADD | |
| 0C4C 60 PUSH1 0x9e | |
| 0C4E 60 PUSH1 0xff | |
| 0C50 16 AND | |
| 0C51 81 DUP2 | |
| 0C52 52 MSTORE | |
| 0C53 60 PUSH1 0x20 | |
| 0C55 01 ADD | |
| 0C56 60 PUSH1 0xe1 | |
| 0C58 60 PUSH1 0xff | |
| 0C5A 16 AND | |
| 0C5B 81 DUP2 | |
| 0C5C 52 MSTORE | |
| 0C5D 60 PUSH1 0x20 | |
| 0C5F 01 ADD | |
| 0C60 60 PUSH1 0xf8 | |
| 0C62 60 PUSH1 0xff | |
| 0C64 16 AND | |
| 0C65 81 DUP2 | |
| 0C66 52 MSTORE | |
| 0C67 60 PUSH1 0x20 | |
| 0C69 01 ADD | |
| 0C6A 60 PUSH1 0x98 | |
| 0C6C 60 PUSH1 0xff | |
| 0C6E 16 AND | |
| 0C6F 81 DUP2 | |
| 0C70 52 MSTORE | |
| 0C71 60 PUSH1 0x20 | |
| 0C73 01 ADD | |
| 0C74 60 PUSH1 0x11 | |
| 0C76 60 PUSH1 0xff | |
| 0C78 16 AND | |
| 0C79 81 DUP2 | |
| 0C7A 52 MSTORE | |
| 0C7B 60 PUSH1 0x20 | |
| 0C7D 01 ADD | |
| 0C7E 60 PUSH1 0x69 | |
| 0C80 60 PUSH1 0xff | |
| 0C82 16 AND | |
| 0C83 81 DUP2 | |
| 0C84 52 MSTORE | |
| 0C85 60 PUSH1 0x20 | |
| 0C87 01 ADD | |
| 0C88 60 PUSH1 0xd9 | |
| 0C8A 60 PUSH1 0xff | |
| 0C8C 16 AND | |
| 0C8D 81 DUP2 | |
| 0C8E 52 MSTORE | |
| 0C8F 60 PUSH1 0x20 | |
| 0C91 01 ADD | |
| 0C92 60 PUSH1 0x8e | |
| 0C94 60 PUSH1 0xff | |
| 0C96 16 AND | |
| 0C97 81 DUP2 | |
| 0C98 52 MSTORE | |
| 0C99 60 PUSH1 0x20 | |
| 0C9B 01 ADD | |
| 0C9C 60 PUSH1 0x94 | |
| 0C9E 60 PUSH1 0xff | |
| 0CA0 16 AND | |
| 0CA1 81 DUP2 | |
| 0CA2 52 MSTORE | |
| 0CA3 60 PUSH1 0x20 | |
| 0CA5 01 ADD | |
| 0CA6 60 PUSH1 0x9b | |
| 0CA8 60 PUSH1 0xff | |
| 0CAA 16 AND | |
| 0CAB 81 DUP2 | |
| 0CAC 52 MSTORE | |
| 0CAD 60 PUSH1 0x20 | |
| 0CAF 01 ADD | |
| 0CB0 60 PUSH1 0x1e | |
| 0CB2 60 PUSH1 0xff | |
| 0CB4 16 AND | |
| 0CB5 81 DUP2 | |
| 0CB6 52 MSTORE | |
| 0CB7 60 PUSH1 0x20 | |
| 0CB9 01 ADD | |
| 0CBA 60 PUSH1 0x87 | |
| 0CBC 60 PUSH1 0xff | |
| 0CBE 16 AND | |
| 0CBF 81 DUP2 | |
| 0CC0 52 MSTORE | |
| 0CC1 60 PUSH1 0x20 | |
| 0CC3 01 ADD | |
| 0CC4 60 PUSH1 0xe9 | |
| 0CC6 60 PUSH1 0xff | |
| 0CC8 16 AND | |
| 0CC9 81 DUP2 | |
| 0CCA 52 MSTORE | |
| 0CCB 60 PUSH1 0x20 | |
| 0CCD 01 ADD | |
| 0CCE 60 PUSH1 0xce | |
| 0CD0 60 PUSH1 0xff | |
| 0CD2 16 AND | |
| 0CD3 81 DUP2 | |
| 0CD4 52 MSTORE | |
| 0CD5 60 PUSH1 0x20 | |
| 0CD7 01 ADD | |
| 0CD8 60 PUSH1 0x55 | |
| 0CDA 60 PUSH1 0xff | |
| 0CDC 16 AND | |
| 0CDD 81 DUP2 | |
| 0CDE 52 MSTORE | |
| 0CDF 60 PUSH1 0x20 | |
| 0CE1 01 ADD | |
| 0CE2 60 PUSH1 0x28 | |
| 0CE4 60 PUSH1 0xff | |
| 0CE6 16 AND | |
| 0CE7 81 DUP2 | |
| 0CE8 52 MSTORE | |
| 0CE9 60 PUSH1 0x20 | |
| 0CEB 01 ADD | |
| 0CEC 60 PUSH1 0xdf | |
| 0CEE 60 PUSH1 0xff | |
| 0CF0 16 AND | |
| 0CF1 81 DUP2 | |
| 0CF2 52 MSTORE | |
| 0CF3 60 PUSH1 0x20 | |
| 0CF5 01 ADD | |
| 0CF6 60 PUSH1 0x8c | |
| 0CF8 60 PUSH1 0xff | |
| 0CFA 16 AND | |
| 0CFB 81 DUP2 | |
| 0CFC 52 MSTORE | |
| 0CFD 60 PUSH1 0x20 | |
| 0CFF 01 ADD | |
| 0D00 60 PUSH1 0xa1 | |
| 0D02 60 PUSH1 0xff | |
| 0D04 16 AND | |
| 0D05 81 DUP2 | |
| 0D06 52 MSTORE | |
| 0D07 60 PUSH1 0x20 | |
| 0D09 01 ADD | |
| 0D0A 60 PUSH1 0x89 | |
| 0D0C 60 PUSH1 0xff | |
| 0D0E 16 AND | |
| 0D0F 81 DUP2 | |
| 0D10 52 MSTORE | |
| 0D11 60 PUSH1 0x20 | |
| 0D13 01 ADD | |
| 0D14 60 PUSH1 0x0d | |
| 0D16 60 PUSH1 0xff | |
| 0D18 16 AND | |
| 0D19 81 DUP2 | |
| 0D1A 52 MSTORE | |
| 0D1B 60 PUSH1 0x20 | |
| 0D1D 01 ADD | |
| 0D1E 60 PUSH1 0xbf | |
| 0D20 60 PUSH1 0xff | |
| 0D22 16 AND | |
| 0D23 81 DUP2 | |
| 0D24 52 MSTORE | |
| 0D25 60 PUSH1 0x20 | |
| 0D27 01 ADD | |
| 0D28 60 PUSH1 0xe6 | |
| 0D2A 60 PUSH1 0xff | |
| 0D2C 16 AND | |
| 0D2D 81 DUP2 | |
| 0D2E 52 MSTORE | |
| 0D2F 60 PUSH1 0x20 | |
| 0D31 01 ADD | |
| 0D32 60 PUSH1 0x42 | |
| 0D34 60 PUSH1 0xff | |
| 0D36 16 AND | |
| 0D37 81 DUP2 | |
| 0D38 52 MSTORE | |
| 0D39 60 PUSH1 0x20 | |
| 0D3B 01 ADD | |
| 0D3C 60 PUSH1 0x68 | |
| 0D3E 60 PUSH1 0xff | |
| 0D40 16 AND | |
| 0D41 81 DUP2 | |
| 0D42 52 MSTORE | |
| 0D43 60 PUSH1 0x20 | |
| 0D45 01 ADD | |
| 0D46 60 PUSH1 0x41 | |
| 0D48 60 PUSH1 0xff | |
| 0D4A 16 AND | |
| 0D4B 81 DUP2 | |
| 0D4C 52 MSTORE | |
| 0D4D 60 PUSH1 0x20 | |
| 0D4F 01 ADD | |
| 0D50 60 PUSH1 0x99 | |
| 0D52 60 PUSH1 0xff | |
| 0D54 16 AND | |
| 0D55 81 DUP2 | |
| 0D56 52 MSTORE | |
| 0D57 60 PUSH1 0x20 | |
| 0D59 01 ADD | |
| 0D5A 60 PUSH1 0x2d | |
| 0D5C 60 PUSH1 0xff | |
| 0D5E 16 AND | |
| 0D5F 81 DUP2 | |
| 0D60 52 MSTORE | |
| 0D61 60 PUSH1 0x20 | |
| 0D63 01 ADD | |
| 0D64 60 PUSH1 0x0f | |
| 0D66 60 PUSH1 0xff | |
| 0D68 16 AND | |
| 0D69 81 DUP2 | |
| 0D6A 52 MSTORE | |
| 0D6B 60 PUSH1 0x20 | |
| 0D6D 01 ADD | |
| 0D6E 60 PUSH1 0xb0 | |
| 0D70 60 PUSH1 0xff | |
| 0D72 16 AND | |
| 0D73 81 DUP2 | |
| 0D74 52 MSTORE | |
| 0D75 60 PUSH1 0x20 | |
| 0D77 01 ADD | |
| 0D78 60 PUSH1 0x54 | |
| 0D7A 60 PUSH1 0xff | |
| 0D7C 16 AND | |
| 0D7D 81 DUP2 | |
| 0D7E 52 MSTORE | |
| 0D7F 60 PUSH1 0x20 | |
| 0D81 01 ADD | |
| 0D82 60 PUSH1 0xbb | |
| 0D84 60 PUSH1 0xff | |
| 0D86 16 AND | |
| 0D87 81 DUP2 | |
| 0D88 52 MSTORE | |
| 0D89 60 PUSH1 0x20 | |
| 0D8B 01 ADD | |
| 0D8C 60 PUSH1 0x16 | |
| 0D8E 60 PUSH1 0xff | |
| 0D90 16 AND | |
| 0D91 81 DUP2 | |
| 0D92 52 MSTORE [M_A255, M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL] | |
| 0D93 50 POP [M_A0, 0x00, 0x60, M_Z0, C, 0x01e1, FSEL...] | |
| // Expands memory by 0x60 bytes. | |
| 0D94 92 SWAP3 [M_Z0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL...] | |
| 0D95 50 POP [0x00, 0x60, M_A0, C, 0x01e1, FSEL...] | |
| 0D96 60 PUSH1 0x60 [0x60, 0x00, 0x60, M_A0, C, 0x01e1, FSEL...] | |
| 0D98 60 PUSH1 0x40 [0x40, 0x60, 0x00, 0x60, M_A0, C, 0x01e1, FSEL...] | |
| 0D9A 51 MLOAD [M_B0, 0x60, 0x00, 0x60, M_A0, C, 0x01e1, FSEL...] | |
| 0D9B 90 SWAP1 [0x60, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL...] | |
| 0D9C 81 DUP2 [M_B0, 0x60, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL...] | |
| 0D9D 01 ADD [M_C0, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL...] // M_C0 := 0x60 + M_B0 | |
| 0D9E 60 PUSH1 0x40 [0x40, M_C0, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL...] | |
| 0DA0 52 MSTORE [M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL...] // memory@0x40 := M_C0 | |
| // Writes the constants from XXXX into memory. | |
| 0DA1 80 DUP1 [M_B0, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DA2 60 PUSH1 0x26 [0x26, M_B0, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DA4 81 DUP2 [M_B0, 0x26, M_B0, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DA5 52 MSTORE [M_B0, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] // memory@M_B0 := 0x00..0026 | |
| 0DA6 60 PUSH1 0x20 [0x20, M_B0, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DA8 01 ADD [M_B1, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DA9 7F PUSH32 0x311dfa5451963f33b16e63f0c62278c9b907e43d1961cdf9f590a0c3b351c040 | |
| [0x31..40, M_B1, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DCA 81 DUP2 [M_B1, 0x31..40, M_B1, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DCB 52 MSTORE [M_B1, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] // memory@M_B1 := 0x31..40 | |
| 0DCC 60 PUSH1 0x20 [0x20, M_B1, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DCE 01 ADD [M_B2, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DCF 7F PUSH32 0x19cccb8314030000000000000000000000000000000000000000000000000000 | |
| [0x19..00, M_B2, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DF0 81 DUP2 [M_B2, 0x19..00, M_B2, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DF1 52 MSTORE [M_B2, M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] // memory@M_B2 := 0x19..00 | |
| 0DF2 50 POP [M_B0, 0x00, 0x60, M_A0, C, 0x01e1, FSEL] | |
| 0DF3 91 SWAP2 [0x60, 0x00, M_B0, M_A0, C, 0x01e1, FSEL] | |
| 0DF4 50 POP [0x00, M_B0, M_A0, C, 0x01e1, FSEL] | |
| 0DF5 60 PUSH1 0x00 [0x00, 0x00, M_B0, M_A0, C, 0x01e1, FSEL] | |
| 0DF7 90 SWAP1 [0x00, 0x00, M_B0, M_A0, C, 0x01e1, FSEL] | |
| 0DF8 50 POP [0x00, M_B0, M_A0, C, 0x01e1, FSEL] | |
| // 1st: [ 0x00, M_B0, M_A0, C, 0x01e1, FSEL] | |
| // 2nd: [IDX_B_PLUS_1, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| // while (stack[0] < *stack[-1]) | |
| 0DF9 5B JUMPDEST [IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // IDX_B starts at 0x00, outer loop index | |
| 0DFA 81 DUP2 [M_B0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0DFB 51 MLOAD [0x26, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0DFC 81 DUP2 [IDX_B, 0x26, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0DFD 10 LT [VAL_IDX_B, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // VAL_IDX_B := IDX_B < 0x26 | |
| 0DFE 15 ISZERO [INVAL_IDX_B, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0DFF 61 PUSH2 0x0ec7 [0x0ec7, INVAL_IDX_B, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E02 57 *JUMPI [IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Stack delta = +0 | |
| // Outputs[264] | |
| // { | |
| // ... | |
| // @0D94 stack[-3] = memory[0x40:0x60] | |
| // @0DA0 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 | |
| // @0DA5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 | |
| // @0DCB memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x311dfa5451963f33b16e63f0c62278c9b907e43d1961cdf9f590a0c3b351c040 | |
| // @0DF1 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x19cccb8314030000000000000000000000000000000000000000000000000000 | |
| // @0DF3 stack[-2] = memory[0x40:0x60] | |
| // @0DF7 stack[-1] = 0x00 | |
| // } | |
| // Block ends with conditional jump to 0x0ec7, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) | |
| label_0E03: | |
| // Incoming jump from 0x0E02, if not !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) | |
| // Incoming jump from 0x0E02, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) | |
| // Inputs[4] | |
| // { | |
| // @0E03 stack[-4] | |
| // @0E26 stack[-2] | |
| // @0E27 stack[-1] | |
| // @0E29 memory[stack[-2]:stack[-2] + 0x20] | |
| // } | |
| // Gets least significant byte of WEIRD_PREV | |
| 0E03 83 DUP4 [WEIRD_PREV, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E04 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 | |
| [0x01..00, WEIRD_PREV, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E25 02 MUL [WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E26 82 DUP3 [M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E27 82 DUP3 [IDX_B, M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E28 81 DUP2 [M_B0, IDX_B, M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E29 51 MLOAD [0x26, IDX_B, M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E2A 81 DUP2 [IDX_B, 0x26, IDX_B, M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E2B 10 LT [0x01, IDX_B, M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E2C 15 ISZERO [0x00, IDX_B, M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E2D 15 ISZERO [0x01, IDX_B, M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E2E 61 PUSH2 0x0e33 [0x0e33, 0x01, IDX_B, M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E31 57 *JUMPI [IDX_B, M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Stack delta = +3 | |
| // Outputs[3] | |
| // { | |
| // @0E25 stack[0] = 0x0100000000000000000000000000000000000000000000000000000000000000 * stack[-4] | |
| // @0E26 stack[1] = stack[-2] | |
| // @0E27 stack[2] = stack[-1] | |
| // } | |
| // Block ends with conditional jump to 0x0e33, if !!(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) | |
| label_0E32: | |
| // Incoming jump from 0x0E31, if not !!(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) | |
| 0E32 FE *ASSERT | |
| // Stack delta = +0 | |
| // Outputs[1] { @0E32 assert(); } | |
| // Block terminates | |
| label_0E33: | |
| // Incoming jump from 0x0E31, if !!(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) | |
| // Inputs[6] | |
| // { | |
| // @0E34 stack[-2] | |
| // @0E34 stack[-1] | |
| // @0E39 stack[-3] | |
| // @0E3B memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] | |
| // @0EB2 stack[-6] | |
| // @0EB3 stack[-7] | |
| // } | |
| // func_thing(index into M_B0, M_B0, C_?) | |
| // Overwrites M_B0 with C ^ M_B0 | |
| 0E33 5B JUMPDEST [IDX_B, M_B0, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E34 90 SWAP1 [M_B0, IDX_B, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E35 60 PUSH1 0x20 [0x20, M_B0, IDX_B, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E37 01 ADD [M_B1, IDX_B, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E38 01 ADD [M_B_I, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // M_B_I := memory location of IDX_B-th char in B str | |
| 0E39 81 DUP2 [WEIRD_PREV_0, M_B_I, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E3A 81 DUP2 [M_B_I, WEIRD_PREV_0, M_B_I, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E3B 51 MLOAD [B_I_WORD, WEIRD_PREV_0, M_B_I, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // B_I_WORD := word starting at IDX_B-th char in B str | |
| 0E3C 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 | |
| [0x01..00, B_I_WORD, WEIRD_PREV_0, M_B_I, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E5D 90 SWAP1 [B_I_WORD, 0x01..00, WEIRD_PREV_0, M_B_I, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E5E 04 DIV [B_I, WEIRD_PREV_0, M_B_I, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // B_I := IDX_B-th char in B str | |
| 0E5F 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 | |
| [0x01..00, B_I, WEIRD_PREV_0, M_B_I, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E80 02 MUL [B_I_BIG, WEIRD_PREV_0, M_B_I, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // B_I_BIG := big-endian IDX_B-th char in B str | |
| 0E81 18 XOR [K_I_BIG, M_B_I, WEIRD_PREV_0, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // big-endian IDX_B-th char in B str XOR'd with WEIRD_PREV_0 | |
| 0E82 91 SWAP2 [WEIRD_PREV_0, M_B_I, K_I_BIG, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E83 50 POP [M_B_I, K_I_BIG, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E84 90 SWAP1 [K_I_BIG, M_B_I, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0E85 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff | |
| [0x00..ff, K_I_BIG, M_B_I, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EA5 19 NOT [0xFF..00, K_I_BIG, M_B_I, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EA6 16 AND [K_I_BIG, M_B_I, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EA7 90 SWAP1 [M_B_I, K_I_BIG, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EA8 81 DUP2 [K_I_BIG, M_B_I, K_I_BIG, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EA9 60 PUSH1 0x00 [0x00, K_I_BIG, M_B_I, K_I_BIG, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EAB 1A BYTE [K_I, M_B_I, K_I_BIG, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // K_I := IDX_B-th char in B str XOR'd with WEIRD_PREV_0 | |
| 0EAC 90 SWAP1 [M_B_I, K_I, K_I_BIG, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EAD 53 MSTORE8 [K_I_BIG, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // memory@M_B_I[idex] := K_I | |
| 0EAE 50 POP [IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EAF 61 PUSH2 0x0eb8 [0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EB2 83 DUP4 [M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EB3 85 DUP6 [WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EB4 61 PUSH2 0x115e [0x115e, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EB7 56 *JUMP [WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Stack delta = +0 | |
| // Outputs[4] | |
| // { | |
| // @0EAD memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) ~ stack[-3]), 0x00) | |
| // @0EAF stack[-3] = 0x0eb8 | |
| // @0EB2 stack[-2] = stack[-6] | |
| // @0EB3 stack[-1] = stack[-7] | |
| // } | |
| // Block ends with call to 0x115e, returns to 0x0EB8 | |
| label_0EB8: | |
| // Incoming return from call to 0x115E at 0x0EB7 | |
| // Inputs[3] | |
| // { | |
| // @0EB9 stack[-1] | |
| // @0EB9 stack[-5] | |
| // @0EBB stack[-2] | |
| // } | |
| 0EB8 5B JUMPDEST [WEIRD_ROLLED, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EB9 93 SWAP4 [WEIRD_PREV, IDX_B, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| 0EBA 50 POP [IDX_B, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| 0EBB 80 DUP1 [IDX_B, IDX_B, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| 0EBC 80 DUP1 [IDX_B, IDX_B, IDX_B, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| 0EBD 60 PUSH1 0x01 [0x01, IDX_B, IDX_B, IDX_B, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| 0EBF 01 ADD [IDX_B_PLUS_1, IDX_B, IDX_B, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| 0EC0 91 SWAP2 [IDX_B, IDX_B, IDX_B_PLUS_1, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| 0EC1 50 POP [IDX_B, IDX_B_PLUS_1, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| 0EC2 50 POP [IDX_B_PLUS_1, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| 0EC3 61 PUSH2 0x0df9 [0x0df9, IDX_B_PLUS_1, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| 0EC6 56 *JUMP [IDX_B_PLUS_1, M_B0, M_A0, WEIRD_ROLLED, 0x01e1, FSEL] | |
| // Stack delta = -1 | |
| // Outputs[2] | |
| // { | |
| // @0EB9 stack[-5] = stack[-1] | |
| // @0EC0 stack[-2] = 0x01 + stack[-2] | |
| // } | |
| // Block ends with unconditional jump to 0x0df9 | |
| label_0EC7: | |
| // Incoming jump from 0x0E02, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) | |
| // Incoming jump from 0x0E02, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) | |
| // Inputs[3] | |
| // { | |
| // @0ECC memory[0x40:0x60] | |
| // @0F27 memory[0x40:0x60] | |
| // @0F2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // } | |
| 0EC7 5B JUMPDEST [0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EC8 60 PUSH1 0x60 [0x60, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ECA 60 PUSH1 0x40 [0x40, 0x60, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ECC 51 MLOAD [M_C0, 0x60, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ECD 90 SWAP1 [0x60, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ECE 81 DUP2 [M_C0, 0x60, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ECF 01 ADD [M_D0, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ED0 60 PUSH1 0x40 [0x40, M_D0, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ED2 52 MSTORE [M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ED3 80 DUP1 [M_C0, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ED4 60 PUSH1 0x26 [0x26, M_C0, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ED6 81 DUP2 [M_C0, 0x26, M_C0, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ED7 52 MSTORE [M_C0, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0ED8 60 PUSH1 0x20 [0x20, M_C0, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EDA 01 ADD [M_C1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EDB 7F PUSH32 0x504354467b763332795f3533637532335f336e633279703731306e5f34313930 | |
| [0x50.., M_C1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EFC 81 DUP2 [M_C1, 0x50.., M_C1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EFD 52 MSTORE [M_C1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0EFE 60 PUSH1 0x20 [0x20, M_C1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F00 01 ADD [M_C2, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F01 7F PUSH32 0x323137686d7d0000000000000000000000000000000000000000000000000000 | |
| [0x32.., M_C2, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F22 81 DUP2 [M_C2, 0x32.., M_C2, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F23 52 MSTORE [M_C2, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F24 50 POP [M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // memcopy sequence start | |
| 0F25 60 PUSH1 0x40 [0x40, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F27 51 MLOAD [M_D0, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F28 60 PUSH1 0x20 [0x20, M_D0, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F2A 01 ADD [M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F2B 80 DUP1 [M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F2C 82 DUP3 [M_C0, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F2D 80 DUP1 [M_C0, M_C0, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F2E 51 MLOAD [0x26, M_C0, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F2F 90 SWAP1 [M_C0, 0x26, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F30 60 PUSH1 0x20 [0x20, M_C0, 0x26, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F32 01 ADD [M_C1, 0x26, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F33 90 SWAP1 [0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F34 80 DUP1 [0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F35 83 DUP4 [M_D1, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F36 83 DUP4 [M_C1, M_D1, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // iteration 0: [M_C1, M_D1, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // iteration 1: [M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F37 5B JUMPDEST [M_CX, M_DX, REMAIN, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F38 60 PUSH1 0x20 [0x20, M_CX, M_DX, REMAIN, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F3A 83 DUP4 [REMAIN, 0x20, M_CX, M_DX, REMAIN, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F3B 10 LT [!ISWORDLEFT, M_CX, M_DX, REMAIN, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F3C 15 ISZERO [ISWORDLEFT, M_CX, M_DX, REMAIN, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F3D 15 ISZERO [!ISWORDLEFT, M_CX, M_DX, REMAIN, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F3E 61 PUSH2 0x0f5c [0x0f5c, !ISWORDLEFT, M_CX, M_DX, REMAIN, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F41 57 *JUMPI [M_CX, M_DX, REMAIN, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Stack delta = +8 | |
| // Outputs[12] | |
| // { | |
| // @0ECD stack[0] = memory[0x40:0x60] | |
| // @0ED2 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 | |
| // @0ED7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 | |
| // @0EFD memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x504354467b763332795f3533637532335f336e633279703731306e5f34313930 | |
| // @0F23 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x323137686d7d0000000000000000000000000000000000000000000000000000 | |
| // @0F2A stack[1] = 0x20 + memory[0x40:0x60] | |
| // @0F2B stack[2] = 0x20 + memory[0x40:0x60] | |
| // @0F33 stack[3] = 0x20 + memory[0x40:0x60] | |
| // @0F33 stack[4] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // @0F34 stack[5] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // @0F35 stack[6] = 0x20 + memory[0x40:0x60] | |
| // @0F36 stack[7] = 0x20 + memory[0x40:0x60] | |
| // } | |
| // Block ends with conditional jump to 0x0f5c, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20) | |
| label_0F42: | |
| // Incoming jump from 0x0F41, if not !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20) | |
| // Incoming jump from 0x0F41, if not !!(stack[-3] < 0x20) | |
| // Inputs[4] | |
| // { | |
| // @0F42 stack[-1] | |
| // @0F43 memory[stack[-1]:stack[-1] + 0x20] | |
| // @0F44 stack[-2] | |
| // @0F54 stack[-3] | |
| // } | |
| // memcopy part 1 | |
| 0F42 80 DUP1 [M_C1, M_C1, M_D1, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F43 51 MLOAD [C_0_WORD, M_C1, M_D1, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F44 82 DUP3 [M_D1, C_0_WORD, M_C1, M_D1, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F45 52 MSTORE [M_C1, M_D1, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F46 60 PUSH1 0x20 [0x20, M_C1, M_D1, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F48 82 DUP3 [M_D1, 0x20, M_C1, M_D1, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F49 01 ADD [M_D2, M_C1, M_D1, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F4A 91 SWAP2 [M_D1, M_C1, M_D2, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F4B 50 POP [M_C1, M_D2, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F4C 60 PUSH1 0x20 [0x20, M_C1, M_D2, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F4E 81 DUP2 [M_C1, 0x20, M_C1, M_D2, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F4F 01 ADD [M_C2, M_C1, M_D2, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F50 90 SWAP1 [M_C1, M_C2, M_D2, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F51 50 POP [M_C2, M_D2, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F52 60 PUSH1 0x20 [0x20, M_C2, M_D2, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F54 83 DUP4 [0x26, 0x20, M_C2, M_D2, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F55 03 SUB [0x06, M_C2, M_D2, 0x26, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F56 92 SWAP3 [0x26, M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F57 50 POP [M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F58 61 PUSH2 0x0f37 [0x0f37, M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F5B 56 *JUMP [M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Stack delta = +0 | |
| // Outputs[4] | |
| // { | |
| // @0F45 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] | |
| // @0F4A stack[-2] = stack[-2] + 0x20 | |
| // @0F50 stack[-1] = stack[-1] + 0x20 | |
| // @0F56 stack[-3] = stack[-3] - 0x20 | |
| // } | |
| // Block ends with unconditional jump to 0x0f37 | |
| label_0F5C: | |
| // Incoming jump from 0x0F41, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20) | |
| // Incoming jump from 0x0F41, if !!(stack[-3] < 0x20) | |
| // Inputs[12] | |
| // { | |
| // @0F5F stack[-3] | |
| // @0F6A stack[-1] | |
| // @0F6B memory[stack[-1]:stack[-1] + 0x20] | |
| // @0F6E stack[-2] | |
| // @0F6F memory[stack[-2]:stack[-2] + 0x20] | |
| // @0F7C stack[-4] | |
| // @0F7C stack[-5] | |
| // @0F7E stack[-6] | |
| // @0F7F stack[-8] | |
| // @0F84 memory[0x40:0x60] | |
| // @0F93 memory[0x40:0x60] | |
| // @0F97 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // } | |
| // memcopy part 2 | |
| 0F5C 5B JUMPDEST [M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F5D 60 PUSH1 0x01 [0x01, M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F5F 83 DUP4 [0x06, 0x01, M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F60 60 PUSH1 0x20 [0x20, 0x06, 0x01, M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F62 03 SUB [0x1a, 0x01, M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F63 61 PUSH2 0x0100 [0x0100, 0x1a, 0x01, M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F66 0A EXP [0x00000000000100..., 0x01, M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F67 03 SUB [0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F68 80 DUP1 [0x000000000000ff..., 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F69 19 NOT [0xffffffffffff00..., 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F6A 82 DUP3 [M_C2, 0xffffffffffff00..., 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F6B 51 MLOAD [C_32_WORD, 0xffffffffffff00..., 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F6C 16 AND [C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F6D 81 DUP2 [0x000000000000ff..., C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F6E 84 DUP5 [M_D2, 0x000000000000ff..., C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F6F 51 MLOAD [0x00, 0x000000000000ff..., C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F70 16 AND [0x00, C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F71 80 DUP1 [0x00, 0x00, C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F72 82 DUP3 [C_32_WORD, 0x00, 0x00, C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F73 17 OR [C_32_WORD, 0x00, C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F74 85 DUP6 [M_D2, C_32_WORD, 0x00, C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F75 52 MSTORE [0x00, C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F76 50 POP [C_32_WORD, 0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F77 50 POP [0x000000000000ff..., M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F78 50 POP [M_C2, M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F79 50 POP [M_D2, 0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F7A 50 POP [0x06, 0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F7B 50 POP [0x26, M_C1, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F7C 90 SWAP1 [M_C1, 0x26, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F7D 50 POP [0x26, M_D1, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F7E 01 ADD [M_DE, M_D1, M_C0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F7F 91 SWAP2 [M_C0, M_D1, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F80 50 POP [M_D1, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F81 50 POP [M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F82 60 PUSH1 0x40 [0x40, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F84 51 MLOAD [M_D0, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F85 60 PUSH1 0x20 [0x20, M_D0, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F87 81 DUP2 [M_D0, 0x20, M_D0, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F88 83 DUP4 [M_DE, M_D0, 0x20, M_D0, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F89 03 SUB [0x46, 0x20, M_D0, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F8A 03 SUB [0x26, M_D0, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F8B 81 DUP2 [M_D0, 0x26, M_D0, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F8C 52 MSTORE [M_D0, M_DE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F8D 90 SWAP1 [M_DE, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F8E 60 PUSH1 0x40 [0x40, M_DE, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F90 52 MSTORE [M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // begin memcopy sequence | |
| 0F91 60 PUSH1 0x40 [0x40, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F93 51 MLOAD [M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F94 80 DUP1 [M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F95 82 DUP3 [M_D0, M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F96 80 DUP1 [M_D0, M_D0, M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F97 51 MLOAD [0x26, M_D0, M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F98 90 SWAP1 [M_D0, 0x26, M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F99 60 PUSH1 0x20 [0x20, M_D0, 0x26, M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F9B 01 ADD [M_D1, 0x26, M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F9C 90 SWAP1 [0x26, M_D1, M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F9D 80 DUP1 [0x26, 0x26, M_D1, M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F9E 83 DUP4 [M_E0, 0x26, 0x26, M_D1, M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0F9F 83 DUP4 [M_D1, M_E0, 0x26, 0x26, M_D1, M_E0, M_E0, M_D0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FA0 5B JUMPDEST | |
| 0FA1 60 PUSH1 0x20 | |
| 0FA3 83 DUP4 | |
| 0FA4 10 LT | |
| 0FA5 15 ISZERO | |
| 0FA6 15 ISZERO | |
| 0FA7 61 PUSH2 0x0fc5 | |
| 0FAA 57 *JUMPI | |
| // Stack delta = +0 | |
| // Outputs[11] | |
| // { | |
| // @0F75 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) | |
| // @0F8C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] + stack[-6]) - memory[0x40:0x60] - 0x20 | |
| // @0F8D stack[-8] = memory[0x40:0x60] | |
| // @0F90 memory[0x40:0x60] = stack[-4] + stack[-6] | |
| // @0F93 stack[-7] = memory[0x40:0x60] | |
| // @0F94 stack[-6] = memory[0x40:0x60] | |
| // @0F9C stack[-5] = 0x20 + memory[0x40:0x60] | |
| // @0F9C stack[-4] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // @0F9D stack[-3] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // @0F9E stack[-2] = memory[0x40:0x60] | |
| // @0F9F stack[-1] = 0x20 + memory[0x40:0x60] | |
| // } | |
| // Block ends with conditional jump to 0x0fc5, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20) | |
| label_0FAB: | |
| // Incoming jump from 0x0FAA, if not !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20) | |
| // Incoming jump from 0x0FAA, if not !!(stack[-3] < 0x20) | |
| // Inputs[4] | |
| // { | |
| // @0FAB stack[-1] | |
| // @0FAC memory[stack[-1]:stack[-1] + 0x20] | |
| // @0FAD stack[-2] | |
| // @0FBD stack[-3] | |
| // } | |
| 0FAB 80 DUP1 | |
| 0FAC 51 MLOAD | |
| 0FAD 82 DUP3 | |
| 0FAE 52 MSTORE | |
| 0FAF 60 PUSH1 0x20 | |
| 0FB1 82 DUP3 | |
| 0FB2 01 ADD | |
| 0FB3 91 SWAP2 | |
| 0FB4 50 POP | |
| 0FB5 60 PUSH1 0x20 | |
| 0FB7 81 DUP2 | |
| 0FB8 01 ADD | |
| 0FB9 90 SWAP1 | |
| 0FBA 50 POP | |
| 0FBB 60 PUSH1 0x20 | |
| 0FBD 83 DUP4 | |
| 0FBE 03 SUB | |
| 0FBF 92 SWAP3 | |
| 0FC0 50 POP | |
| 0FC1 61 PUSH2 0x0fa0 | |
| 0FC4 56 *JUMP | |
| // Stack delta = +0 | |
| // Outputs[4] | |
| // { | |
| // @0FAE memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] | |
| // @0FB3 stack[-2] = stack[-2] + 0x20 | |
| // @0FB9 stack[-1] = stack[-1] + 0x20 | |
| // @0FBF stack[-3] = stack[-3] - 0x20 | |
| // } | |
| // Block ends with unconditional jump to 0x0fa0 | |
| label_0FC5: | |
| // Incoming jump from 0x0FAA, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20) | |
| // Incoming jump from 0x0FAA, if !!(stack[-3] < 0x20) | |
| // Inputs[14] | |
| // { | |
| // @0FC8 stack[-3] | |
| // @0FD3 stack[-1] | |
| // @0FD4 memory[stack[-1]:stack[-1] + 0x20] | |
| // @0FD7 stack[-2] | |
| // @0FD8 memory[stack[-2]:stack[-2] + 0x20] | |
| // @0FE5 stack[-4] | |
| // @0FE5 stack[-5] | |
| // @0FE7 stack[-6] | |
| // @0FE8 stack[-8] | |
| // @0FED memory[0x40:0x60] | |
| // @0FF2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] | |
| // @0FF7 stack[-10] | |
| // @0FFA memory[0x40:0x60] | |
| // @1001 memory[stack[-10]:stack[-10] + 0x20] | |
| // } | |
| 0FC5 5B JUMPDEST | |
| 0FC6 60 PUSH1 0x01 | |
| 0FC8 83 DUP4 | |
| 0FC9 60 PUSH1 0x20 | |
| 0FCB 03 SUB | |
| 0FCC 61 PUSH2 0x0100 | |
| 0FCF 0A EXP | |
| 0FD0 03 SUB | |
| 0FD1 80 DUP1 | |
| 0FD2 19 NOT | |
| 0FD3 82 DUP3 | |
| 0FD4 51 MLOAD | |
| 0FD5 16 AND | |
| 0FD6 81 DUP2 | |
| 0FD7 84 DUP5 | |
| 0FD8 51 MLOAD | |
| 0FD9 16 AND | |
| 0FDA 80 DUP1 | |
| 0FDB 82 DUP3 | |
| 0FDC 17 OR | |
| 0FDD 85 DUP6 | |
| 0FDE 52 MSTORE | |
| 0FDF 50 POP | |
| 0FE0 50 POP | |
| 0FE1 50 POP | |
| 0FE2 50 POP | |
| 0FE3 50 POP | |
| 0FE4 50 POP | |
| 0FE5 90 SWAP1 | |
| 0FE6 50 POP | |
| 0FE7 01 ADD | |
| 0FE8 91 SWAP2 | |
| 0FE9 50 POP | |
| 0FEA 50 POP | |
| 0FEB 60 PUSH1 0x40 | |
| 0FED 51 MLOAD [M_E0, M_EE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FEE 80 DUP1 [M_E0, M_E0, M_EE, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FEF 91 SWAP2 [M_EE, M_E0, M_E0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FF0 03 SUB [0x26, M_E0, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FF1 90 SWAP1 [M_E0, 0x26, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FF2 20 SHA3 [HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FF3 60 PUSH1 0x00 [0x00, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FF5 19 NOT [0xff..., HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FF6 16 AND [HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FF7 82 DUP3 [M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // start memcopy sequence | |
| 0FF8 60 PUSH1 0x40 [0x40, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FFA 51 MLOAD [M_E0, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FFB 60 PUSH1 0x20 [0x20, M_E0, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FFD 01 ADD [M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FFE 80 DUP1 [M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 0FFF 82 DUP3 [M_B0, M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1000 80 DUP1 [M_B0, M_B0, M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1001 51 MLOAD [0x26, M_B0, M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1002 90 SWAP1 [M_B0, 0x26, M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1003 60 PUSH1 0x20 [0x20, M_B0, 0x26, M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1005 01 ADD [M_B1, 0x26, M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1006 90 SWAP1 [0x26, M_B1, M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1007 80 DUP1 [0x26, 0x26, M_B1, M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1008 83 DUP4 [M_E1, 0x26, 0x26, M_B1, M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1009 83 DUP4 [M_B1, M_E1, 0x26, 0x26, M_B1, M_E1, M_E1, M_B0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 100A 5B JUMPDEST | |
| 100B 60 PUSH1 0x20 | |
| 100D 83 DUP4 | |
| 100E 10 LT | |
| 100F 15 ISZERO | |
| 1010 15 ISZERO | |
| 1011 61 PUSH2 0x102f | |
| 1014 57 *JUMPI | |
| // Stack delta = +1 | |
| // Outputs[10] | |
| // { | |
| // @0FDE memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) | |
| // @0FF6 stack[-8] = ~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) | |
| // @0FF7 stack[-7] = stack[-10] | |
| // @0FFD stack[-6] = 0x20 + memory[0x40:0x60] | |
| // @0FFE stack[-5] = 0x20 + memory[0x40:0x60] | |
| // @1006 stack[-3] = memory[stack[-10]:stack[-10] + 0x20] | |
| // @1006 stack[-4] = 0x20 + stack[-10] | |
| // @1007 stack[-2] = memory[stack[-10]:stack[-10] + 0x20] | |
| // @1008 stack[-1] = 0x20 + memory[0x40:0x60] | |
| // @1009 stack[0] = 0x20 + stack[-10] | |
| // } | |
| // Block ends with conditional jump to 0x102f, if !!(memory[stack[-10]:stack[-10] + 0x20] < 0x20) | |
| label_1015: | |
| // Incoming jump from 0x1014, if not !!(memory[stack[-10]:stack[-10] + 0x20] < 0x20) | |
| // Incoming jump from 0x1014, if not !!(stack[-3] < 0x20) | |
| // Inputs[4] | |
| // { | |
| // @1015 stack[-1] | |
| // @1016 memory[stack[-1]:stack[-1] + 0x20] | |
| // @1017 stack[-2] | |
| // @1027 stack[-3] | |
| // } | |
| 1015 80 DUP1 | |
| 1016 51 MLOAD | |
| 1017 82 DUP3 | |
| 1018 52 MSTORE | |
| 1019 60 PUSH1 0x20 | |
| 101B 82 DUP3 | |
| 101C 01 ADD | |
| 101D 91 SWAP2 | |
| 101E 50 POP | |
| 101F 60 PUSH1 0x20 | |
| 1021 81 DUP2 | |
| 1022 01 ADD | |
| 1023 90 SWAP1 | |
| 1024 50 POP | |
| 1025 60 PUSH1 0x20 | |
| 1027 83 DUP4 | |
| 1028 03 SUB | |
| 1029 92 SWAP3 | |
| 102A 50 POP | |
| 102B 61 PUSH2 0x100a | |
| 102E 56 *JUMP | |
| // Stack delta = +0 | |
| // Outputs[4] | |
| // { | |
| // @1018 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] | |
| // @101D stack[-2] = stack[-2] + 0x20 | |
| // @1023 stack[-1] = stack[-1] + 0x20 | |
| // @1029 stack[-3] = stack[-3] - 0x20 | |
| // } | |
| // Block ends with unconditional jump to 0x100a | |
| label_102F: | |
| // Incoming jump from 0x1014, if !!(memory[stack[-10]:stack[-10] + 0x20] < 0x20) | |
| // Incoming jump from 0x1014, if !!(stack[-3] < 0x20) | |
| // Inputs[12] | |
| // { | |
| // @1032 stack[-3] | |
| // @103D stack[-1] | |
| // @103E memory[stack[-1]:stack[-1] + 0x20] | |
| // @1041 stack[-2] | |
| // @1042 memory[stack[-2]:stack[-2] + 0x20] | |
| // @104F stack[-4] | |
| // @104F stack[-5] | |
| // @1051 stack[-6] | |
| // @1052 stack[-8] | |
| // @1057 memory[0x40:0x60] | |
| // @1066 memory[0x40:0x60] | |
| // @106A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // } | |
| 102F 5B JUMPDEST | |
| 1030 60 PUSH1 0x01 | |
| 1032 83 DUP4 | |
| 1033 60 PUSH1 0x20 | |
| 1035 03 SUB | |
| 1036 61 PUSH2 0x0100 | |
| 1039 0A EXP | |
| 103A 03 SUB | |
| 103B 80 DUP1 | |
| 103C 19 NOT | |
| 103D 82 DUP3 | |
| 103E 51 MLOAD | |
| 103F 16 AND | |
| 1040 81 DUP2 | |
| 1041 84 DUP5 | |
| 1042 51 MLOAD | |
| 1043 16 AND | |
| 1044 80 DUP1 | |
| 1045 82 DUP3 | |
| 1046 17 OR | |
| 1047 85 DUP6 | |
| 1048 52 MSTORE | |
| 1049 50 POP | |
| 104A 50 POP | |
| 104B 50 POP | |
| 104C 50 POP | |
| 104D 50 POP | |
| 104E 50 POP | |
| 104F 90 SWAP1 | |
| 1050 50 POP | |
| 1051 01 ADD | |
| 1052 91 SWAP2 | |
| 1053 50 POP | |
| 1054 50 POP | |
| 1055 60 PUSH1 0x40 | |
| 1057 51 MLOAD | |
| 1058 60 PUSH1 0x20 | |
| 105A 81 DUP2 | |
| 105B 83 DUP4 | |
| 105C 03 SUB | |
| 105D 03 SUB | |
| 105E 81 DUP2 | |
| 105F 52 MSTORE | |
| 1060 90 SWAP1 | |
| 1061 60 PUSH1 0x40 | |
| 1063 52 MSTORE [M_E0, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1064 60 PUSH1 0x40 | |
| 1066 51 MLOAD | |
| 1067 80 DUP1 | |
| 1068 82 DUP3 | |
| 1069 80 DUP1 | |
| 106A 51 MLOAD | |
| 106B 90 SWAP1 | |
| 106C 60 PUSH1 0x20 | |
| 106E 01 ADD | |
| 106F 90 SWAP1 | |
| 1070 80 DUP1 | |
| 1071 83 DUP4 | |
| 1072 83 DUP4 | |
| 1073 5B JUMPDEST | |
| 1074 60 PUSH1 0x20 | |
| 1076 83 DUP4 | |
| 1077 10 LT | |
| 1078 15 ISZERO | |
| 1079 15 ISZERO | |
| 107A 61 PUSH2 0x1098 | |
| 107D 57 *JUMPI | |
| // Stack delta = +0 | |
| // Outputs[11] | |
| // { | |
| // @1048 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) | |
| // @105F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] + stack[-6]) - memory[0x40:0x60] - 0x20 | |
| // @1060 stack[-8] = memory[0x40:0x60] | |
| // @1063 memory[0x40:0x60] = stack[-4] + stack[-6] | |
| // @1066 stack[-7] = memory[0x40:0x60] | |
| // @1067 stack[-6] = memory[0x40:0x60] | |
| // @106F stack[-5] = 0x20 + memory[0x40:0x60] | |
| // @106F stack[-4] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // @1070 stack[-3] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] | |
| // @1071 stack[-2] = memory[0x40:0x60] | |
| // @1072 stack[-1] = 0x20 + memory[0x40:0x60] | |
| // } | |
| // Block ends with conditional jump to 0x1098, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20) | |
| label_107E: | |
| // Incoming jump from 0x107D, if not !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20) | |
| // Incoming jump from 0x107D, if not !!(stack[-3] < 0x20) | |
| // Inputs[4] | |
| // { | |
| // @107E stack[-1] | |
| // @107F memory[stack[-1]:stack[-1] + 0x20] | |
| // @1080 stack[-2] | |
| // @1090 stack[-3] | |
| // } | |
| 107E 80 DUP1 | |
| 107F 51 MLOAD | |
| 1080 82 DUP3 | |
| 1081 52 MSTORE | |
| 1082 60 PUSH1 0x20 | |
| 1084 82 DUP3 | |
| 1085 01 ADD | |
| 1086 91 SWAP2 | |
| 1087 50 POP | |
| 1088 60 PUSH1 0x20 | |
| 108A 81 DUP2 | |
| 108B 01 ADD | |
| 108C 90 SWAP1 | |
| 108D 50 POP | |
| 108E 60 PUSH1 0x20 | |
| 1090 83 DUP4 | |
| 1091 03 SUB | |
| 1092 92 SWAP3 | |
| 1093 50 POP | |
| 1094 61 PUSH2 0x1073 | |
| 1097 56 *JUMP | |
| // Stack delta = +0 | |
| // Outputs[4] | |
| // { | |
| // @1081 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] | |
| // @1086 stack[-2] = stack[-2] + 0x20 | |
| // @108C stack[-1] = stack[-1] + 0x20 | |
| // @1092 stack[-3] = stack[-3] - 0x20 | |
| // } | |
| // Block ends with unconditional jump to 0x1073 | |
| label_1098: | |
| // Incoming jump from 0x107D, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20) | |
| // Incoming jump from 0x107D, if !!(stack[-3] < 0x20) | |
| // Inputs[12] | |
| // { | |
| // @109B stack[-3] | |
| // @10A6 stack[-1] | |
| // @10A7 memory[stack[-1]:stack[-1] + 0x20] | |
| // @10AA stack[-2] | |
| // @10AB memory[stack[-2]:stack[-2] + 0x20] | |
| // @10B8 stack[-4] | |
| // @10B8 stack[-5] | |
| // @10BA stack[-6] | |
| // @10BB stack[-8] | |
| // @10C0 memory[0x40:0x60] | |
| // @10C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] | |
| // @10CA stack[-9] | |
| // } | |
| 1098 5B JUMPDEST | |
| 1099 60 PUSH1 0x01 | |
| 109B 83 DUP4 | |
| 109C 60 PUSH1 0x20 | |
| 109E 03 SUB | |
| 109F 61 PUSH2 0x0100 | |
| 10A2 0A EXP | |
| 10A3 03 SUB | |
| 10A4 80 DUP1 | |
| 10A5 19 NOT | |
| 10A6 82 DUP3 | |
| 10A7 51 MLOAD | |
| 10A8 16 AND | |
| 10A9 81 DUP2 | |
| 10AA 84 DUP5 | |
| 10AB 51 MLOAD | |
| 10AC 16 AND | |
| 10AD 80 DUP1 | |
| 10AE 82 DUP3 | |
| 10AF 17 OR | |
| 10B0 85 DUP6 | |
| 10B1 52 MSTORE | |
| 10B2 50 POP | |
| 10B3 50 POP | |
| 10B4 50 POP | |
| 10B5 50 POP | |
| 10B6 50 POP | |
| 10B7 50 POP | |
| 10B8 90 SWAP1 | |
| 10B9 50 POP | |
| 10BA 01 ADD | |
| 10BB 91 SWAP2 | |
| 10BC 50 POP | |
| 10BD 50 POP | |
| 10BE 60 PUSH1 0x40 | |
| 10C0 51 MLOAD | |
| 10C1 80 DUP1 | |
| 10C2 91 SWAP2 | |
| 10C3 03 SUB | |
| 10C4 90 SWAP1 | |
| 10C5 20 SHA3 | |
| 10C6 60 PUSH1 0x00 | |
| 10C8 19 NOT | |
| 10C9 16 AND [OURHASH, HASH, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 10CA 14 EQ [SUCCESS, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 10CB 15 ISZERO [!SUCCESS, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 10CC 15 ISZERO [SUCCESS, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 10CD 61 PUSH2 0x113e [0x113e, SUCCESS, 0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 10D0 57 *JUMPI [0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Stack delta = -9 | |
| // Outputs[1] { @10B1 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) } | |
| // Block ends with conditional jump to 0x113e, if !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) == stack[-9]) | |
| label_10D1: | |
| // Incoming jump from 0x10D0, if not !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) == stack[-9]) | |
| // Inputs[3] | |
| // { | |
| // @10D3 memory[0x40:0x60] | |
| // @1138 memory[0x40:0x60] | |
| // @113D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] | |
| // } | |
| 10D1 60 PUSH1 0x40 | |
| 10D3 51 MLOAD | |
| 10D4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 | |
| 10F5 81 DUP2 | |
| 10F6 52 MSTORE | |
| 10F7 60 PUSH1 0x04 | |
| 10F9 01 ADD | |
| 10FA 80 DUP1 | |
| 10FB 80 DUP1 | |
| 10FC 60 PUSH1 0x20 | |
| 10FE 01 ADD | |
| 10FF 82 DUP3 | |
| 1100 81 DUP2 | |
| 1101 03 SUB | |
| 1102 82 DUP3 | |
| 1103 52 MSTORE | |
| 1104 60 PUSH1 0x10 | |
| 1106 81 DUP2 | |
| 1107 52 MSTORE | |
| 1108 60 PUSH1 0x20 | |
| 110A 01 ADD | |
| 110B 80 DUP1 | |
| 110C 7F PUSH32 0x736f6c76652f6e6f742d736f6c76656400000000000000000000000000000000 | |
| 112D 81 DUP2 | |
| 112E 52 MSTORE | |
| 112F 50 POP | |
| 1130 60 PUSH1 0x20 | |
| 1132 01 ADD | |
| 1133 91 SWAP2 | |
| 1134 50 POP | |
| 1135 50 POP | |
| 1136 60 PUSH1 0x40 | |
| 1138 51 MLOAD | |
| 1139 80 DUP1 | |
| 113A 91 SWAP2 | |
| 113B 03 SUB | |
| 113C 90 SWAP1 | |
| 113D FD *REVERT | |
| // Stack delta = +0 | |
| // Outputs[5] | |
| // { | |
| // @10F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 | |
| // @1103 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) | |
| // @1107 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x10 | |
| // @112E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x736f6c76652f6e6f742d736f6c76656400000000000000000000000000000000 | |
| // @113D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); | |
| // } | |
| // Block terminates | |
| label_113E: | |
| // Incoming jump from 0x10D0, if !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) == stack[-9]) | |
| // Inputs[2] | |
| // { | |
| // @1149 storage[0x00] | |
| // @115D stack[-5] | |
| // } | |
| 113E 5B JUMPDEST [0x26, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 113F 60 PUSH1 0x01 | |
| 1141 60 PUSH1 0x00 | |
| 1143 80 DUP1 | |
| 1144 61 PUSH2 0x0100 | |
| 1147 0A EXP | |
| 1148 81 DUP2 | |
| 1149 54 SLOAD | |
| 114A 81 DUP2 | |
| 114B 60 PUSH1 0xff | |
| 114D 02 MUL | |
| 114E 19 NOT | |
| 114F 16 AND | |
| 1150 90 SWAP1 | |
| 1151 83 DUP4 | |
| 1152 15 ISZERO | |
| 1153 15 ISZERO | |
| 1154 02 MUL | |
| 1155 17 OR | |
| 1156 90 SWAP1 | |
| 1157 55 SSTORE | |
| 1158 50 POP | |
| 1159 50 POP | |
| 115A 50 POP | |
| 115B 50 POP | |
| 115C 50 POP | |
| 115D 56 *JUMP | |
| // Stack delta = -5 | |
| // Outputs[1] { @1157 storage[0x00] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x00]) } | |
| // Block ends with unconditional jump to stack[-5] | |
| label_115E: | |
| // PUT ZEROS ON THE STACK! | |
| // Incoming call from 0x0EB7, returns to 0x0EB8 | |
| 115E 5B JUMPDEST [WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 115F 60 PUSH1 0x00 [0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1161 80 DUP1 [0x00, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1162 60 PUSH1 0x00 [0x00, 0x00, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1164 80 DUP1 [0x00, 0x00, 0x00, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1165 60 PUSH1 0x00 [0x00, 0x00, 0x00, 0x00, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1167 91 SWAP2 [0x00, 0x00, 0x00, 0x00, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1168 50 POP [0x00, 0x00, 0x00, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Iter: 0 [0x00, 0x00, 0x00, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Iter: 1 [0x00, 0x08, A_0, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Iter: 2 [0x00, 0x10, ACC_A, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // ... [0x00, IDX_A_PLUS_8, WEIRD_NEW, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| /* | |
| * ACC_A := 0 | |
| * for (IDX_A := 0; IDX_A < 256; IDX_A += 8) { | |
| * offset := M_A0 + (C_X * 0x20) | |
| * T_X := mload(offset) & 0xFF | |
| * ACC_A := ACC_A | (T_X * (2 ** IDX_A)) | |
| * } | |
| */ | |
| 1169 5B JUMPDEST [0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 116A 61 PUSH2 0x0100 [0x0100, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 116D 82 DUP3 [IDX_A, 0x0100, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 116E 10 LT [0x01, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 116F 15 ISZERO [0x00, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1170 61 PUSH2 0x11a9 [0x11a9, 0x00, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1173 57 *JUMPI [0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Stack delta = +4 | |
| // Outputs[4] | |
| // { | |
| // @115F stack[0] = 0x00 | |
| // @1161 stack[1] = 0x00 | |
| // @1164 stack[3] = 0x00 | |
| // @1167 stack[2] = 0x00 | |
| // } | |
| // Block ends with conditional jump to 0x11a9, if !(0x00 < 0x0100) | |
| label_1174: | |
| // Incoming jump from 0x1173, if not !(stack[-2] < 0x0100) | |
| // Incoming jump from 0x1173, if not !(0x00 < 0x0100) | |
| // Inputs[3] | |
| // { | |
| // @1174 stack[-2] | |
| // @1175 stack[-6] | |
| // @1179 stack[-5] | |
| // } | |
| 1174 81 DUP2 [IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1175 86 DUP7 [M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1176 60 PUSH1 0xff [0xFF, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1178 84 DUP5 [IDX_A, 0xFF, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1179 88 DUP9 [WEIRD_PREV, IDX_A, 0xFF, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 117A 90 SWAP1 [IDX_A, WEIRD_PREV, 0xFF, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Extracts the byte beginning at the IDX_Ath bit from WEIRD_PREV. | |
| 117B 60 PUSH1 0x02 [0x02, IDX_A, WEIRD_PREV, 0xff, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 117D 0A EXP [BIT_J, WEIRD_PREV, 0xff, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // BIT_J := 2 ** IDX_A | |
| 117E 90 SWAP1 [WEIRD_PREV, BIT_J, 0xff, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 117F 04 DIV [WEIRD_PREV_SHIFT_J, 0xff, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // WEIRD_PREV_SHIFT_J := WEIRD_PREV / (2 ** IDX_A) | |
| 1180 16 AND [WEIRD_PREV_J, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] // WEIRD_PREV_J byte of WEIRD_PREV with j-bit offset | |
| // Probably bounds checking? | |
| 1181 61 PUSH2 0x0100 [0x0100, WEIRD_PREV_J, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1184 81 DUP2 [WEIRD_PREV_J, 0x0100, WEIRD_PREV_J, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1185 10 LT [0x01, WEIRD_PREV_J, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1186 15 ISZERO [0x00, WEIRD_PREV_J, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1187 15 ISZERO [0x01, WEIRD_PREV_J, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1188 61 PUSH2 0x118d [0x118d, 0x01, WEIRD_PREV_J, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 118B 57 *JUMPI [WEIRD_PREV_J, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Stack delta = +3 | |
| // Outputs[3] | |
| // { | |
| // @1174 stack[0] = stack[-2] | |
| // @1175 stack[1] = stack[-6] | |
| // @1180 stack[2] = stack[-5] / 0x02 ** stack[-2] & 0xff | |
| // } | |
| // Block ends with conditional jump to 0x118d, if !!(stack[-5] / 0x02 ** stack[-2] & 0xff < 0x0100) | |
| label_118C: | |
| // Incoming jump from 0x118B, if not !!(stack[-5] / 0x02 ** stack[-2] & 0xff < 0x0100) | |
| 118C FE *ASSERT | |
| // Stack delta = +0 | |
| // Outputs[1] { @118C assert(); } | |
| // Block terminates | |
| label_118D: | |
| // Incoming jump from 0x118B, if !!(stack[-5] / 0x02 ** stack[-2] & 0xff < 0x0100) | |
| // Inputs[6] | |
| // { | |
| // @1190 stack[-1] | |
| // @1191 stack[-2] | |
| // @1192 memory[0x20 * stack[-1] + stack[-2]:0x20 * stack[-1] + stack[-2] + 0x20] | |
| // @1196 stack[-3] | |
| // @119B stack[-6] | |
| // @11A1 stack[-5] | |
| // } | |
| 118D 5B JUMPDEST [WEIRD_PREV_J, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 118E 60 PUSH1 0x20 [0x20, WEIRD_PREV_J, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1190 02 MUL [WEIRD_PREV_J_SPACED, M_A0, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1191 01 ADD [M_A_WP_J, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1192 51 MLOAD [A_WP_J, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1193 60 PUSH1 0xff [0xFF, A_WP_J, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1195 16 AND [A_WP_J, IDX_A, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1196 90 SWAP1 [IDX_A, A_WP_J, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1197 60 PUSH1 0x02 [0x02, IDX_A, A_WP_J, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 1199 0A EXP [BIT_J, A_WP_J, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 119A 02 MUL [A_WP_J_SHIFTED, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 119B 83 DUP4 [WEIRD, A_WP_J_SHIFTED, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 119C 17 OR [WEIRD_NEW, 0x00, IDX_A, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 119D 92 SWAP3 [WEIRD, 0x00, IDX_A, WEIRD_NEW, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 119E 50 POP [0x00, IDX_A, WEIRD_NEW, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 119F 60 PUSH1 0x08 [0x08, 0x00, IDX_A, WEIRD_NEW, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11A1 82 DUP3 [IDX_A, 0x08, 0x00, IDX_A, WEIRD_NEW, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11A2 01 ADD [IDX_A_PLUS_8, 0x00, IDX_A, WEIRD_NEW, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11A3 91 SWAP2 [IDX_A, 0x00, IDX_A_PLUS_8, WEIRD_NEW, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11A4 50 POP [0x00, IDX_A_PLUS_8, WEIRD_NEW, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11A5 61 PUSH2 0x1169 [0x1169, 0x00, IDX_A_PLUS_8, WEIRD_NEW, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11A8 56 *JUMP [0x00, IDX_A_PLUS_8, WEIRD_NEW, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Stack delta = -3 | |
| // Outputs[2] | |
| // { | |
| // @119D stack[-6] = stack[-6] | 0x02 ** stack[-3] * (0xff & memory[0x20 * stack[-1] + stack[-2]:0x20 * stack[-1] + stack[-2] + 0x20]) | |
| // @11A3 stack[-5] = stack[-5] + 0x08 | |
| // } | |
| // Block ends with unconditional jump to 0x1169 | |
| label_11A9: | |
| // Incoming jump from 0x1173, if !(stack[-2] < 0x0100) | |
| // Incoming jump from 0x1173, if !(0x00 < 0x0100) | |
| // Inputs[5] | |
| // { | |
| // @11AC stack[-3] | |
| // @11AE stack[-1] | |
| // @11C8 stack[-4] | |
| // @11CD stack[-7] | |
| // @11CE stack[-6] | |
| // } | |
| 11A9 5B JUMPDEST [0x00, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11AA 60 PUSH1 0xff [0xff, 0x00, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11AC 83 DUP4 [WEIRD, 0xff, 0x00, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11AD 16 AND [WEIRD_BYTE, 0x00, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11AE 90 SWAP1 [0x00, WEIRD_BYTE, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11AF 50 POP [WEIRD_BYTE, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11B0 60 PUSH1 0x08 [0x08, WEIRD_BYTE, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11B2 83 DUP4 [WEIRD, 0x08, WEIRD_BYTE, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11B3 90 SWAP1 [0x08, WEIRD, WEIRD_BYTE, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11B4 60 PUSH1 0x02 [0x02, 0x08, WEIRD, WEIRD_BYTE, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11B6 0A EXP [0x0100, WEIRD, WEIRD_BYTE, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11B7 90 SWAP1 [WEIRD, 0x0100, WEIRD_BYTE, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11B8 04 DIV [WEIRD_SHR8, WEIRD_BYTE, 0x0100, WEIRD, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11B9 92 SWAP3 [WEIRD, WEIRD_BYTE, 0x0100, WEIRD_SHR8, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11BA 50 POP [WEIRD_BYTE, 0x0100, WEIRD_SHR8, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11BB 60 PUSH1 0xf8 [0xf8, WEIRD_BYTE, 0x0100, WEIRD_SHR8, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11BD 81 DUP2 [WEIRD_BYTE, 0xf8, WEIRD_BYTE, 0x0100, WEIRD_SHR8, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11BE 90 SWAP1 [0xf8, WEIRD_BYTE, WEIRD_BYTE, 0x0100, WEIRD_SHR8, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11BF 60 PUSH1 0x02 [0x02, 0xf8, WEIRD_BYTE, WEIRD_BYTE, 0x0100, WEIRD_SHR8, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11C1 0A EXP [0x01...00, WEIRD_BYTE, WEIRD_BYTE, 0x0100, WEIRD_SHR8, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11C2 02 MUL [WEIRD_BYTE_BIG, WEIRD_BYTE, 0x0100, WEIRD_SHR8, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11C3 83 DUP4 [WEIRD_SHR8, WEIRD_BYTE_BIG, WEIRD_BYTE, 0x0100, WEIRD_SHR8, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11C4 17 OR [WEIRD_ROLLED, WEIRD_BYTE, 0x0100, WEIRD_SHR8, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11C5 92 SWAP3 [WEIRD_SHR8, WEIRD_BYTE, 0x0100, WEIRD_ROLLED, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11C6 50 POP [WEIRD_BYTE, 0x0100, WEIRD_ROLLED, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11C7 82 DUP3 [WEIRD_ROLLED, WEIRD_BYTE, 0x0100, WEIRD_ROLLED, 0x00, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11C8 93 SWAP4 [0x00, WEIRD_BYTE, 0x0100, WEIRD_ROLLED, WEIRD_ROLLED, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11C9 50 POP [WEIRD_BYTE, 0x0100, WEIRD_ROLLED, WEIRD_ROLLED, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11CA 50 POP [0x0100, WEIRD_ROLLED, WEIRD_ROLLED, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11CB 50 POP [WEIRD_ROLLED, WEIRD_ROLLED, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11CC 50 POP [WEIRD_ROLLED, WEIRD_PREV, M_A0, 0x0eb8, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11CD 92 SWAP3 [0x0eb8, WEIRD_PREV, M_A0, WEIRD_ROLLED, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11CE 91 SWAP2 [M_A0, WEIRD_PREV, 0x0eb8, WEIRD_ROLLED, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11CF 50 POP [WEIRD_PREV, 0x0eb8, WEIRD_ROLLED, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11D0 50 POP [0x0eb8, WEIRD_ROLLED, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| 11D1 56 *JUMP [WEIRD_ROLLED, IDX_B, M_B0, M_A0, WEIRD_PREV, 0x01e1, FSEL] | |
| // Stack delta = -6 | |
| // Outputs[1] { @11CD stack[-7] = stack[-3] / 0x02 ** 0x08 | 0x02 ** 0xf8 * (stack[-3] & 0xff) } | |
| // Block ends with unconditional jump to stack[-7] | |
| label_11D2: | |
| // Incoming call from 0x02BC, returns to 0x02BD | |
| // Inputs[3] | |
| // { | |
| // @11D8 memory[0x40:0x60] | |
| // @11E9 code.length | |
| // @11F5 stack[-1] | |
| // } | |
| 11D2 5B JUMPDEST [0x02bd, C, 0x01e1, FSEL] | |
| // Expands memory by 0x2000 bytes. | |
| 11D3 61 PUSH2 0x2000 [0x2000, 0x02bd, C, 0x01e1, FSEL] | |
| 11D6 60 PUSH1 0x40 [0x40, 0x2000, 0x02bd, C, 0x01e1, FSEL] | |
| 11D8 51 MLOAD [M_Z0, 0x2000, 0x02bd, C, 0x01e1, FSEL] | |
| 11D9 90 SWAP1 [0x2000, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11DA 81 DUP2 [M_Z0, 0x2000, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11DB 01 ADD [M_Y0, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11DC 60 PUSH1 0x40 [0x40, M_Y0, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11DE 52 MSTORE [M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| // Clears 0x2000 bytes of memory starting at M_Z0 | |
| 11DF 80 DUP1 [M_Z0, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11E0 61 PUSH2 0x0100 [0x0100, M_Z0, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11E3 90 SWAP1 [M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11E4 60 PUSH1 0x20 [0x20, M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11E6 82 DUP3 [0x0100, 0x20, M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11E7 02 MUL [0x2000, M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11E8 80 DUP1 [0x2000, 0x2000, M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11E9 38 CODESIZE [DSZ, 0x2000, 0x2000, M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11EA 83 DUP4 [M_Z0, DSZ, 0x2000, 0x2000, M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11EB 39 CODECOPY [0x2000, M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11EC 80 DUP1 [0x2000, 0x2000, M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11ED 82 DUP3 [M_Z0, 0x2000, 0x2000, M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11EE 01 ADD [M_Y0, 0x2000, M_Z0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11EF 91 SWAP2 [M_Z0, 0x2000, M_Y0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11F0 50 POP [0x2000, M_Y0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11F1 50 POP [M_Y0, 0x0100, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11F2 90 SWAP1 [0x0100, MY_0, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11F3 50 POP [MY_0, M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11F4 50 POP [M_Z0, 0x02bd, C, 0x01e1, FSEL] | |
| 11F5 90 SWAP1 [0x02bd, M_Z0, C, 0x01e1, FSEL] | |
| 11F6 56 *JUMP [M_Z0, C, 0x01e1, FSEL] | |
| // Stack delta = +0 | |
| // Outputs[3] | |
| // { | |
| // @11DE memory[0x40:0x60] = memory[0x40:0x60] + 0x2000 | |
| // @11EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x0100 * 0x20] = code[code.length:code.length + 0x0100 * 0x20] | |
| // @11F5 stack[-1] = memory[0x40:0x60] | |
| // } | |
| // Block ends with unconditional jump to stack[-1] | |
| 11F7 00 *STOP | |
| 11F8 A1 LOG1 | |
| 11F9 65 PUSH6 0x627a7a723058 | |
| 1200 20 SHA3 | |
| 1201 F9 F9 | |
| 1202 DD DD | |
| 1203 CD CD | |
| 1204 56 *JUMP | |
| 1205 B8 B8 | |
| 1206 B4 B4 | |
| 1207 4B 4B | |
| 1208 18 XOR | |
| 1209 80 DUP1 | |
| 120A 3C EXTCODECOPY | |
| 120B 6E PUSH15 0xa863a18fdbf5027368521d2414bab4 | |
| 121B DB DB | |
| 121C 11 GT | |
| 121D 84 DUP5 | |
| 121E 7C PUSH29 0x5ebe0029 |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment