Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
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