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