| 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