int **preferd(unsigned n, unsigned *pref_size) {
  unsigned N = 1 << n;
  unsigned i, j, k;
  int l;
  unsigned mls_size = 0;
  int **m = mls(n, &mls_size, 1);
  int mini_val1 = -1;
  int mini_val2 = -1 + (1 << ((n + 2) / 2));
  int mini_val3 = -1 - (1 << ((n + 2) / 2));
  char mat[mls_size][mls_size];
  unsigned pair[mls_size + 1], depth = 0, pdepth = 1;
  int **prefm, *prefmp;
  for (i = 0; i < mls_size; i++) {
    mat[i][i] = 0;
    for (j = i + 1; j < mls_size; j++) {
      char flag = 1;
      for (k = 0; k < N - 1; k++) {
        int inn = innerPro(m[i], m[j], N - 1, k);
        if (inn != mini_val1 && inn != mini_val2 && inn != mini_val3) {
          flag = 0;
          break;
        }
      }
      mat[i][j] = flag;
      mat[j][i] = flag;
    }
  }
  pair[depth] = 0;
  while (pdepth != depth) {
    pdepth = depth;
    for (i = pair[depth] + 1; i < mls_size; i++) {
      if (mat[pair[depth]][i]) {
        int flag = 1;
        for (l = depth - 1; l >= 0; l--)
          if (mat[pair[l]][i] != 1) {
            flag = 0;
            break;
          }
        if (flag)
          pair[++depth] = i;
      }
    }
  }
  *pref_size = depth + 1;
  prefm = malloc(sizeof(int *) * (*pref_size));
  prefmp = malloc(sizeof(int) * (*pref_size) * (N - 1));
  for (i = 0; i < depth + 1; i++) {
    prefm[i] = prefmp + i * (N - 1);
    for (j = 0; j < N - 1; j++)
      prefm[i][j] = m[pair[i]][j];
  }
  free(*m);
  free(m);
  return prefm;
}


x86 assembly (clang, -O0):
<preferd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x4(%rbp),%cl
mov    $0x1,%edx
mov    %edx,-0xa4(%rbp)
mov    %edx,%eax
shl    %cl,%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x4(%rbp),%edi
xor    %eax,%eax
lea    -0x28(%rbp),%rsi
call   1060 <mls@plt>
mov    %eax,%ecx
mov    -0xa4(%rbp),%eax
movslq %ecx,%rcx
mov    %rcx,-0x30(%rbp)
movl   $0xffffffff,-0x34(%rbp)
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
shr    %ecx
shl    %cl,%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2,%eax
mov    %al,%cl
shr    %cl
mov    $0xfffffffe,%eax
rol    %cl,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
mov    %rax,-0xa0(%rbp)
mov    %rsp,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rax,%rdx
imul   %rdx,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x98(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x90(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x1,-0x68(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    134a <preferd+0x20a>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
mov    -0x18(%rbp),%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    1337 <preferd+0x1f7>
movb   $0x1,-0x79(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    12ee <preferd+0x1ae>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,8),%rdi
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
mov    -0x20(%rbp),%ecx
mov    $0x0,%al
call   1050 <innerPro@plt>
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     12db <preferd+0x19b>
mov    -0x80(%rbp),%eax
cmp    -0x38(%rbp),%eax
je     12db <preferd+0x19b>
mov    -0x80(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     12db <preferd+0x19b>
movb   $0x0,-0x79(%rbp)
jmp    12ee <preferd+0x1ae>
jmp    12e0 <preferd+0x1a0>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1274 <preferd+0x134>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rsi
mov    -0x79(%rbp),%dil
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
imul   %rsi,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
mov    -0x1c(%rbp),%edx
mov    %dil,(%rcx,%rdx,1)
mov    -0x79(%rbp),%dl
mov    -0x1c(%rbp),%ecx
imul   %rsi,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    125d <preferd+0x11d>
jmp    133c <preferd+0x1fc>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1229 <preferd+0xe9>
mov    -0x90(%rbp),%rax
mov    -0x64(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
cmp    -0x64(%rbp),%eax
je     146f <preferd+0x32f>
mov    -0x90(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    %ecx,-0x68(%rbp)
mov    -0x64(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    146a <preferd+0x32a>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
mov    -0x90(%rbp),%rcx
mov    -0x64(%rbp),%esi
mov    (%rcx,%rsi,4),%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     1457 <preferd+0x317>
movl   $0x1,-0x84(%rbp)
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     142d <preferd+0x2ed>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
mov    -0x90(%rbp),%rcx
movslq -0x24(%rbp),%rsi
mov    (%rcx,%rsi,4),%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x1,%eax
je     141a <preferd+0x2da>
movl   $0x0,-0x84(%rbp)
jmp    142d <preferd+0x2ed>
jmp    141f <preferd+0x2df>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    13ce <preferd+0x28e>
cmpl   $0x0,-0x84(%rbp)
je     1452 <preferd+0x312>
mov    -0x90(%rbp),%rax
mov    -0x18(%rbp),%edx
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x64(%rbp)
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
jmp    1457 <preferd+0x317>
jmp    145c <preferd+0x31c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1380 <preferd+0x240>
jmp    135b <preferd+0x21b>
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,%edi
shl    $0x2,%rdi
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
imul   %rax,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jae    1552 <preferd+0x412>
mov    -0x78(%rbp),%rdx
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,%eax
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x70(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    153f <preferd+0x3ff>
mov    -0x90(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%edx
mov    (%rcx,%rdx,4),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x1c(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x70(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x1c(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14f4 <preferd+0x3b4>
jmp    1544 <preferd+0x404>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14b8 <preferd+0x378>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<preferd>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rsi,-0x90(%rbp)
mov    %edi,%ebx
mov    $0x1,%r15d
mov    $0x1,%r14d
mov    %ebx,%ecx
shl    %cl,%r14d
movl   $0x0,-0x2c(%rbp)
lea    -0x2c(%rbp),%rsi
mov    $0x1,%edx
xor    %eax,%eax
call   1060 <mls@plt>
add    $0x2,%ebx
shr    %ebx
mov    %ebx,%ecx
shl    %cl,%r15d
mov    %r15d,-0x38(%rbp)
mov    $0xfffffffe,%edx
rol    %cl,%edx
mov    %edx,-0x78(%rbp)
mov    %rsp,-0x98(%rbp)
cltq
mov    %rax,-0x80(%rbp)
mov    -0x2c(%rbp),%r11d
mov    %r11,%rax
imul   %r11,%rax
mov    %rsp,%rcx
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rcx,%rsp
mov    -0x2c(%rbp),%ecx
lea    0x1(%rcx),%eax
mov    %rsp,%rdx
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rdx
mov    %rdx,-0x88(%rbp)
mov    %rdx,%rsp
mov    $0x0,%r8d
test   %ecx,%ecx
mov    %r14,-0x50(%rbp)
je     12f1 <preferd+0x1b1>
addl   $0xffffffff,-0x38(%rbp)
lea    -0x1(%r14),%r12d
mov    $0x1,%r15d
xor    %r14d,%r14d
mov    %ecx,%r8d
mov    %r11,-0x60(%rbp)
jmp    1238 <preferd+0xf8>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8d,%ecx
mov    -0x58(%rbp),%r15
mov    -0x48(%rbp),%r14
add    $0x1,%r15
cmp    %rcx,%r14
jae    12f1 <preferd+0x1b1>
mov    %r14,%rsi
imul   %r11,%rsi
mov    -0x40(%rbp),%rax
add    %rax,%rsi
movb   $0x0,(%r14,%rsi,1)
lea    0x1(%r14),%rdx
mov    %r8d,%ecx
mov    %rdx,-0x48(%rbp)
cmp    %rcx,%rdx
jae    1227 <preferd+0xe7>
add    %r14,%rax
mov    %rax,-0x70(%rbp)
mov    %r15,-0x58(%rbp)
mov    %rsi,-0x68(%rbp)
jmp    128f <preferd+0x14f>
nopl   0x0(%rax)
mov    $0x1,%r13b
mov    %r13b,(%rsi,%r15,1)
mov    %r15,%rcx
imul   %r11,%rcx
mov    -0x70(%rbp),%rax
mov    %r13b,(%rax,%rcx,1)
add    $0x1,%r15
cmp    %r15d,%r8d
jbe    1220 <preferd+0xe0>
test   %r12d,%r12d
je     1270 <preferd+0x130>
xor    %ebx,%ebx
jmp    12a8 <preferd+0x168>
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebx
cmp    %ebx,%r12d
je     12e0 <preferd+0x1a0>
mov    -0x80(%rbp),%rax
mov    (%rax,%r14,8),%rdi
mov    (%rax,%r15,8),%rsi
xor    %r13d,%r13d
mov    %r12d,%edx
mov    %ebx,%ecx
xor    %eax,%eax
call   1050 <innerPro@plt>
cmp    $0xffffffff,%eax
je     12a0 <preferd+0x160>
cmp    -0x38(%rbp),%eax
je     12a0 <preferd+0x160>
cmp    -0x78(%rbp),%eax
je     12a0 <preferd+0x160>
jmp    12e3 <preferd+0x1a3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x1,%r13b
mov    -0x2c(%rbp),%r8d
mov    -0x60(%rbp),%r11
mov    -0x68(%rbp),%rsi
jmp    1273 <preferd+0x133>
mov    -0x88(%rbp),%rcx
movl   $0x0,(%rcx)
xor    %edx,%edx
xor    %r9d,%r9d
xor    %r10d,%r10d
mov    -0x40(%rbp),%r14
jmp    131c <preferd+0x1dc>
nopl   0x0(%rax)
mov    %edx,%edi
mov    %r15d,%r9d
mov    %edi,%edx
cmp    %r9d,%r15d
je     1388 <preferd+0x248>
mov    %r9d,%r15d
lea    0x1(%rdx),%eax
cmp    %r8d,%eax
jae    1310 <preferd+0x1d0>
mov    %eax,%esi
mov    %r15d,%r9d
jmp    134b <preferd+0x20b>
xchg   %ax,%ax
add    $0x1,%r9d
mov    %esi,(%rcx,%r9,4)
mov    %esi,%r10d
mov    %esi,%edx
add    $0x1,%rsi
mov    %edx,%edi
mov    %r10d,%edx
cmp    %esi,%r8d
jbe    1315 <preferd+0x1d5>
mov    %edx,%edi
imul   %r11,%rdi
add    %r14,%rdi
cmpb   $0x0,(%rsi,%rdi,1)
je     133d <preferd+0x1fd>
lea    (%r14,%rsi,1),%rdi
lea    -0x1(%r9),%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %ebx,%ebx
js     1330 <preferd+0x1f0>
mov    %ebx,%eax
mov    (%rcx,%rax,4),%eax
imul   %r11,%rax
add    $0xffffffff,%ebx
cmpb   $0x1,(%rdi,%rax,1)
je     1370 <preferd+0x230>
jmp    133d <preferd+0x1fd>
lea    0x1(%r15),%r14d
mov    -0x90(%rbp),%rax
mov    %r14d,(%rax)
lea    0x0(,%r14,8),%rdi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x50(%rbp),%rbx
add    $0xffffffff,%ebx
mov    %rbx,%rdi
imul   %r14,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
inc    %r15d
jne    13f1 <preferd+0x2b1>
mov    -0x80(%rbp),%rbx
mov    (%rbx),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rsp
mov    -0x38(%rbp),%rax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbx,%r15
lea    (%rax,%rbx,4),%rcx
mov    %rcx,-0x70(%rbp)
mov    %r15d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,-0x68(%rbp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x60(%rbp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r12d
and    $0x3,%r12d
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x58(%rbp)
mov    %r15d,%r13d
and    $0x3,%r13d
lea    0x70(%rax),%rcx
mov    %rcx,-0x50(%rbp)
lea    0x10(%rax),%rcx
mov    %rcx,-0x40(%rbp)
mov    %r12,-0x48(%rbp)
shl    $0x5,%r12
lea    0xc(%rax),%rcx
mov    %rcx,-0x78(%rbp)
xor    %r10d,%r10d
xor    %r11d,%r11d
jmp    1470 <preferd+0x330>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r11
add    %r15d,%r10d
cmp    %r14,%r11
je     13c3 <preferd+0x283>
mov    %r11d,%edx
imul   %r15d,%edx
lea    (%rax,%rdx,4),%rcx
mov    -0x38(%rbp),%rsi
mov    %rcx,(%rsi,%r11,8)
test   %r15,%r15
je     1460 <preferd+0x320>
mov    %r10d,%r9d
mov    -0x88(%rbp),%rsi
mov    (%rsi,%r11,4),%edi
mov    -0x80(%rbp),%rsi
mov    (%rsi,%rdi,8),%r8
cmp    $0x8,%r15d
jb     14c2 <preferd+0x382>
lea    (%r8,%r15,4),%rdi
cmp    %rdi,%rcx
jae    1540 <preferd+0x400>
mov    -0x70(%rbp),%rcx
lea    (%rcx,%rdx,4),%rcx
cmp    %r8,%rcx
jbe    1540 <preferd+0x400>
xor    %edx,%edx
mov    %rdx,%rdi
not    %rdi
add    %r15,%rdi
test   %r13,%r13
je     14f1 <preferd+0x3b1>
lea    (%rax,%r9,4),%rbx
mov    %r13,%rcx
nopl   0x0(%rax)
mov    (%r8,%rdx,4),%esi
mov    %esi,(%rbx,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    14e0 <preferd+0x3a0>
cmp    $0x3,%rdi
jb     1460 <preferd+0x320>
mov    -0x78(%rbp),%rcx
lea    (%rcx,%r9,4),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r8,%rdx,4),%ecx
mov    %ecx,-0xc(%rdi,%rdx,4)
mov    0x4(%r8,%rdx,4),%ecx
mov    %ecx,-0x8(%rdi,%rdx,4)
mov    0x8(%r8,%rdx,4),%ecx
mov    %ecx,-0x4(%rdi,%rdx,4)
mov    0xc(%r8,%rdx,4),%ecx
mov    %ecx,(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r15
jne    1510 <preferd+0x3d0>
jmp    1460 <preferd+0x320>
mov    %r15,%rsi
cmpq   $0x18,-0x60(%rbp)
jae    154e <preferd+0x40e>
xor    %edx,%edx
jmp    15c8 <preferd+0x488>
mov    -0x50(%rbp),%rcx
lea    (%rcx,%r9,4),%r15
mov    -0x58(%rbp),%rdi
xor    %edx,%edx
nopl   0x0(%rax)
movups (%r8,%rdx,4),%xmm0
movups 0x10(%r8,%rdx,4),%xmm1
movups %xmm0,-0x70(%r15,%rdx,4)
movups %xmm1,-0x60(%r15,%rdx,4)
movups 0x20(%r8,%rdx,4),%xmm0
movups 0x30(%r8,%rdx,4),%xmm1
movups %xmm0,-0x50(%r15,%rdx,4)
movups %xmm1,-0x40(%r15,%rdx,4)
movups 0x40(%r8,%rdx,4),%xmm0
movups 0x50(%r8,%rdx,4),%xmm1
movups %xmm0,-0x30(%r15,%rdx,4)
movups %xmm1,-0x20(%r15,%rdx,4)
movups 0x60(%r8,%rdx,4),%xmm0
movups 0x70(%r8,%rdx,4),%xmm1
movups %xmm0,-0x10(%r15,%rdx,4)
movups %xmm1,(%r15,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1560 <preferd+0x420>
cmpq   $0x0,-0x48(%rbp)
je     160b <preferd+0x4cb>
lea    0x0(,%r9,4),%rcx
lea    (%rcx,%rdx,4),%rdi
add    -0x40(%rbp),%rdi
lea    (%r8,%rdx,4),%rcx
add    $0x10,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movups -0x10(%rcx,%rdx,1),%xmm0
movups (%rcx,%rdx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rdx,1)
movups %xmm1,(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r12
jne    15f0 <preferd+0x4b0>
mov    -0x68(%rbp),%rcx
mov    %rcx,%rdx
mov    %rsi,%r15
cmp    %rsi,%rcx
je     1460 <preferd+0x320>
jmp    14c4 <preferd+0x384>

LLVM IR (-O0):
define i32** @preferd(i32 %0, i32* %1) {
%3 = alloca i32
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32**
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i8*
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32**
%22 = alloca i32*
%23 = alloca i8
%24 = alloca i32
%25 = alloca i32
store i32 %0, i32* %3
store i32* %1, i32** %4
%26 = load i32, i32* %3
%27 = shl i32 1, %26
store i32 %27, i32* %5
store i32 0, i32* %10
%28 = load i32, i32* %3
%29 = call i32 (i32, i32*, i32, ...) bitcast (i32 (...)* @mls to i32 (i32, i32*, i32, ...)*)(i32 %28, i32* %10, i32 1)
%30 = sext i32 %29 to i64
%31 = inttoptr i64 %30 to i32**
store i32** %31, i32*** %11
store i32 -1, i32* %12
%32 = load i32, i32* %3
%33 = add i32 %32, 2
%34 = udiv i32 %33, 2
%35 = shl i32 1, %34
%36 = add nsw i32 -1, %35
store i32 %36, i32* %13
%37 = load i32, i32* %3
%38 = add i32 %37, 2
%39 = udiv i32 %38, 2
%40 = shl i32 1, %39
%41 = sub nsw i32 -1, %40
store i32 %41, i32* %14
%42 = load i32, i32* %10
%43 = zext i32 %42 to i64
%44 = load i32, i32* %10
%45 = zext i32 %44 to i64
%46 = call i8* @llvm.stacksave()
store i8* %46, i8** %15
%47 = mul nuw i64 %43, %45
%48 = alloca i8, i64 %47
store i64 %43, i64* %16
store i64 %45, i64* %17
%49 = load i32, i32* %10
%50 = add i32 %49, 1
%51 = zext i32 %50 to i64
%52 = alloca i32, i64 %51
store i64 %51, i64* %18
store i32 0, i32* %19
store i32 1, i32* %20
store i32 0, i32* %6
br label %53
53: ; preds = %129, %2
%54 = load i32, i32* %6
%55 = load i32, i32* %10
%56 = icmp ult i32 %54, %55
br i1 %56, label %57, label %132
57: ; preds = %53
%58 = load i32, i32* %6
%59 = zext i32 %58 to i64
%60 = mul nsw i64 %59, %45
%61 = getelementptr inbounds i8, i8* %48, i64 %60
%62 = load i32, i32* %6
%63 = zext i32 %62 to i64
%64 = getelementptr inbounds i8, i8* %61, i64 %63
store i8 0, i8* %64
%65 = load i32, i32* %6
%66 = add i32 %65, 1
store i32 %66, i32* %7
br label %67
67: ; preds = %125, %57
%68 = load i32, i32* %7
%69 = load i32, i32* %10
%70 = icmp ult i32 %68, %69
br i1 %70, label %71, label %128
71: ; preds = %67
store i8 1, i8* %23
store i32 0, i32* %8
br label %72
72: ; preds = %105, %71
%73 = load i32, i32* %8
%74 = load i32, i32* %5
%75 = sub i32 %74, 1
%76 = icmp ult i32 %73, %75
br i1 %76, label %77, label %108
77: ; preds = %72
%78 = load i32**, i32*** %11
%79 = load i32, i32* %6
%80 = zext i32 %79 to i64
%81 = getelementptr inbounds i32*, i32** %78, i64 %80
%82 = load i32*, i32** %81
%83 = load i32**, i32*** %11
%84 = load i32, i32* %7
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds i32*, i32** %83, i64 %85
%87 = load i32*, i32** %86
%88 = load i32, i32* %5
%89 = sub i32 %88, 1
%90 = load i32, i32* %8
%91 = call i32 (i32*, i32*, i32, i32, ...) bitcast (i32 (...)* @innerPro to i32 (i32*, i32*, i32, i32, ...)*)(i32* %82, i32* %87, i32 %89, i32 %90)
store i32 %91, i32* %24
%92 = load i32, i32* %24
%93 = load i32, i32* %12
%94 = icmp ne i32 %92, %93
br i1 %94, label %95, label %104
95: ; preds = %77
%96 = load i32, i32* %24
%97 = load i32, i32* %13
%98 = icmp ne i32 %96, %97
br i1 %98, label %99, label %104
99: ; preds = %95
%100 = load i32, i32* %24
%101 = load i32, i32* %14
%102 = icmp ne i32 %100, %101
br i1 %102, label %103, label %104
103: ; preds = %99
store i8 0, i8* %23
br label %108
104: ; preds = %99, %95, %77
br label %105
105: ; preds = %104
%106 = load i32, i32* %8
%107 = add i32 %106, 1
store i32 %107, i32* %8
br label %72
108: ; preds = %103, %72
%109 = load i8, i8* %23
%110 = load i32, i32* %6
%111 = zext i32 %110 to i64
%112 = mul nsw i64 %111, %45
%113 = getelementptr inbounds i8, i8* %48, i64 %112
%114 = load i32, i32* %7
%115 = zext i32 %114 to i64
%116 = getelementptr inbounds i8, i8* %113, i64 %115
store i8 %109, i8* %116
%117 = load i8, i8* %23
%118 = load i32, i32* %7
%119 = zext i32 %118 to i64
%120 = mul nsw i64 %119, %45
%121 = getelementptr inbounds i8, i8* %48, i64 %120
%122 = load i32, i32* %6
%123 = zext i32 %122 to i64
%124 = getelementptr inbounds i8, i8* %121, i64 %123
store i8 %117, i8* %124
br label %125
125: ; preds = %108
%126 = load i32, i32* %7
%127 = add i32 %126, 1
store i32 %127, i32* %7
br label %67
128: ; preds = %67
br label %129
129: ; preds = %128
%130 = load i32, i32* %6
%131 = add i32 %130, 1
store i32 %131, i32* %6
br label %53
132: ; preds = %53
%133 = load i32, i32* %19
%134 = zext i32 %133 to i64
%135 = getelementptr inbounds i32, i32* %52, i64 %134
store i32 0, i32* %135
br label %136
136: ; preds = %203, %132
%137 = load i32, i32* %20
%138 = load i32, i32* %19
%139 = icmp ne i32 %137, %138
br i1 %139, label %140, label %204
140: ; preds = %136
%141 = load i32, i32* %19
store i32 %141, i32* %20
%142 = load i32, i32* %19
%143 = zext i32 %142 to i64
%144 = getelementptr inbounds i32, i32* %52, i64 %143
%145 = load i32, i32* %144
%146 = add i32 %145, 1
store i32 %146, i32* %6
br label %147
147: ; preds = %200, %140
%148 = load i32, i32* %6
%149 = load i32, i32* %10
%150 = icmp ult i32 %148, %149
br i1 %150, label %151, label %203
151: ; preds = %147
%152 = load i32, i32* %19
%153 = zext i32 %152 to i64
%154 = getelementptr inbounds i32, i32* %52, i64 %153
%155 = load i32, i32* %154
%156 = zext i32 %155 to i64
%157 = mul nsw i64 %156, %45
%158 = getelementptr inbounds i8, i8* %48, i64 %157
%159 = load i32, i32* %6
%160 = zext i32 %159 to i64
%161 = getelementptr inbounds i8, i8* %158, i64 %160
%162 = load i8, i8* %161
%163 = icmp ne i8 %162, 0
br i1 %163, label %164, label %199
164: ; preds = %151
store i32 1, i32* %25
%165 = load i32, i32* %19
%166 = sub i32 %165, 1
store i32 %166, i32* %9
br label %167
167: ; preds = %186, %164
%168 = load i32, i32* %9
%169 = icmp sge i32 %168, 0
br i1 %169, label %170, label %189
170: ; preds = %167
%171 = load i32, i32* %9
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i32, i32* %52, i64 %172
%174 = load i32, i32* %173
%175 = zext i32 %174 to i64
%176 = mul nsw i64 %175, %45
%177 = getelementptr inbounds i8, i8* %48, i64 %176
%178 = load i32, i32* %6
%179 = zext i32 %178 to i64
%180 = getelementptr inbounds i8, i8* %177, i64 %179
%181 = load i8, i8* %180
%182 = sext i8 %181 to i32
%183 = icmp ne i32 %182, 1
br i1 %183, label %184, label %185
184: ; preds = %170
store i32 0, i32* %25
br label %189
185: ; preds = %170
br label %186
186: ; preds = %185
%187 = load i32, i32* %9
%188 = add nsw i32 %187, -1
store i32 %188, i32* %9
br label %167
189: ; preds = %184, %167
%190 = load i32, i32* %25
%191 = icmp ne i32 %190, 0
br i1 %191, label %192, label %198
192: ; preds = %189
%193 = load i32, i32* %6
%194 = load i32, i32* %19
%195 = add i32 %194, 1
store i32 %195, i32* %19
%196 = zext i32 %195 to i64
%197 = getelementptr inbounds i32, i32* %52, i64 %196
store i32 %193, i32* %197
br label %198
198: ; preds = %192, %189
br label %199
199: ; preds = %198, %151
br label %200
200: ; preds = %199
%201 = load i32, i32* %6
%202 = add i32 %201, 1
store i32 %202, i32* %6
br label %147
203: ; preds = %147
br label %136
204: ; preds = %136
%205 = load i32, i32* %19
%206 = add i32 %205, 1
%207 = load i32*, i32** %4
store i32 %206, i32* %207
%208 = load i32*, i32** %4
%209 = load i32, i32* %208
%210 = zext i32 %209 to i64
%211 = mul i64 8, %210
%212 = call i8* @malloc(i64 %211)
%213 = bitcast i8* %212 to i32**
store i32** %213, i32*** %21
%214 = load i32*, i32** %4
%215 = load i32, i32* %214
%216 = zext i32 %215 to i64
%217 = mul i64 4, %216
%218 = load i32, i32* %5
%219 = sub i32 %218, 1
%220 = zext i32 %219 to i64
%221 = mul i64 %217, %220
%222 = call i8* @malloc(i64 %221)
%223 = bitcast i8* %222 to i32*
store i32* %223, i32** %22
store i32 0, i32* %6
br label %224
224: ; preds = %271, %204
%225 = load i32, i32* %6
%226 = load i32, i32* %19
%227 = add i32 %226, 1
%228 = icmp ult i32 %225, %227
br i1 %228, label %229, label %274
229: ; preds = %224
%230 = load i32*, i32** %22
%231 = load i32, i32* %6
%232 = load i32, i32* %5
%233 = sub i32 %232, 1
%234 = mul i32 %231, %233
%235 = zext i32 %234 to i64
%236 = getelementptr inbounds i32, i32* %230, i64 %235
%237 = load i32**, i32*** %21
%238 = load i32, i32* %6
%239 = zext i32 %238 to i64
%240 = getelementptr inbounds i32*, i32** %237, i64 %239
store i32* %236, i32** %240
store i32 0, i32* %7
br label %241
241: ; preds = %267, %229
%242 = load i32, i32* %7
%243 = load i32, i32* %5
%244 = sub i32 %243, 1
%245 = icmp ult i32 %242, %244
br i1 %245, label %246, label %270
246: ; preds = %241
%247 = load i32**, i32*** %11
%248 = load i32, i32* %6
%249 = zext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %52, i64 %249
%251 = load i32, i32* %250
%252 = zext i32 %251 to i64
%253 = getelementptr inbounds i32*, i32** %247, i64 %252
%254 = load i32*, i32** %253
%255 = load i32, i32* %7
%256 = zext i32 %255 to i64
%257 = getelementptr inbounds i32, i32* %254, i64 %256
%258 = load i32, i32* %257
%259 = load i32**, i32*** %21
%260 = load i32, i32* %6
%261 = zext i32 %260 to i64
%262 = getelementptr inbounds i32*, i32** %259, i64 %261
%263 = load i32*, i32** %262
%264 = load i32, i32* %7
%265 = zext i32 %264 to i64
%266 = getelementptr inbounds i32, i32* %263, i64 %265
store i32 %258, i32* %266
br label %267
267: ; preds = %246
%268 = load i32, i32* %7
%269 = add i32 %268, 1
store i32 %269, i32* %7
br label %241
270: ; preds = %241
br label %271
271: ; preds = %270
%272 = load i32, i32* %6
%273 = add i32 %272, 1
store i32 %273, i32* %6
br label %224
274: ; preds = %224
%275 = load i32**, i32*** %11
%276 = load i32*, i32** %275
%277 = bitcast i32* %276 to i8*
%278 = load i32**, i32*** %11
%279 = bitcast i32** %278 to i8*
%280 = load i32**, i32*** %21
%281 = load i8*, i8** %15
ret i32** %280
}

LLVM IR (-O2):
define i32** @preferd(i32 %0, i32* nocapture writeonly %1) {
%3 = alloca i32
%4 = shl nuw i32 1, %0
%5 = bitcast i32* %3 to i8*
store i32 0, i32* %3
%6 = call i32 (i32, i32*, i32, ...) bitcast (i32 (...)* @mls to i32 (i32, i32*, i32, ...)*)(i32 %0, i32* %3, i32 1)
%7 = sext i32 %6 to i64
%8 = inttoptr i64 %7 to i32**
%9 = add i32 %0, 2
%10 = lshr i32 %9, 1
%11 = shl nuw i32 1, %10
%12 = add nsw i32 %11, -1
%13 = xor i32 %11, -1
%14 = load i32, i32* %3
%15 = zext i32 %14 to i64
%16 = call i8* @llvm.stacksave()
%17 = mul nuw i64 %15, %15
%18 = alloca i8, i64 %17
%19 = load i32, i32* %3
%20 = add i32 %19, 1
%21 = zext i32 %20 to i64
%22 = alloca i32, i64 %21
%23 = icmp eq i32 %19, 0
br i1 %23, label %79, label %24
24: ; preds = %2
%25 = add i32 %4, -1
%26 = icmp eq i32 %25, 0
br label %34
27: ; preds = %69
%28 = zext i32 %70 to i64
br label %29
29: ; preds = %27, %34
%30 = phi i64 [ %28, %27 ], [ %42, %34 ]
%31 = phi i32 [ %70, %27 ], [ %35, %34 ]
%32 = icmp ult i64 %41, %30
%33 = add nuw nsw i64 %37, 1
br i1 %32, label %34, label %79
34: ; preds = %24, %29
%35 = phi i32 [ %19, %24 ], [ %31, %29 ]
%36 = phi i64 [ 0, %24 ], [ %41, %29 ]
%37 = phi i64 [ 1, %24 ], [ %33, %29 ]
%38 = mul nuw nsw i64 %36, %15
%39 = getelementptr inbounds i8, i8* %18, i64 %38
%40 = getelementptr inbounds i8, i8* %39, i64 %36
store i8 0, i8* %40
%41 = add nuw nsw i64 %36, 1
%42 = zext i32 %35 to i64
%43 = icmp ult i64 %41, %42
br i1 %43, label %44, label %29
44: ; preds = %34
%45 = getelementptr inbounds i32*, i32** %8, i64 %36
%46 = getelementptr inbounds i8, i8* %18, i64 %36
br label %47
47: ; preds = %44, %69
%48 = phi i32 [ %35, %44 ], [ %70, %69 ]
%49 = phi i32 [ %35, %44 ], [ %71, %69 ]
%50 = phi i64 [ %37, %44 ], [ %76, %69 ]
br i1 %26, label %69, label %51
51: ; preds = %47
%52 = getelementptr inbounds i32*, i32** %8, i64 %50
br label %55
53: ; preds = %55
%54 = icmp eq i32 %65, %25
br i1 %54, label %66, label %55
55: ; preds = %51, %53
%56 = phi i32 [ 0, %51 ], [ %65, %53 ]
%57 = load i32*, i32** %45
%58 = load i32*, i32** %52
%59 = call i32 (i32*, i32*, i32, i32, ...) bitcast (i32 (...)* @innerPro to i32 (i32*, i32*, i32, i32, ...)*)(i32* %57, i32* %58, i32 %25, i32 %56)
%60 = icmp eq i32 %59, -1
%61 = icmp eq i32 %59, %12
%62 = select i1 %60, i1 true, i1 %61
%63 = icmp eq i32 %59, %13
%64 = select i1 %62, i1 true, i1 %63
%65 = add nuw i32 %56, 1
br i1 %64, label %53, label %66
66: ; preds = %55, %53
%67 = phi i8 [ 1, %53 ], [ 0, %55 ]
%68 = load i32, i32* %3
br label %69
69: ; preds = %66, %47
%70 = phi i32 [ %48, %47 ], [ %68, %66 ]
%71 = phi i32 [ %49, %47 ], [ %68, %66 ]
%72 = phi i8 [ 1, %47 ], [ %67, %66 ]
%73 = getelementptr inbounds i8, i8* %39, i64 %50
store i8 %72, i8* %73
%74 = mul nuw nsw i64 %50, %15
%75 = getelementptr inbounds i8, i8* %46, i64 %74
store i8 %72, i8* %75
%76 = add nuw nsw i64 %50, 1
%77 = trunc i64 %76 to i32
%78 = icmp ugt i32 %71, %77
br i1 %78, label %47, label %27
79: ; preds = %29, %2
%80 = phi i32 [ 0, %2 ], [ %31, %29 ]
store i32 0, i32* %22
br label %86
81: ; preds = %125, %86
%82 = phi i32 [ %87, %86 ], [ %126, %125 ]
%83 = phi i32 [ %88, %86 ], [ %127, %125 ]
%84 = phi i32 [ %89, %86 ], [ %128, %125 ]
%85 = icmp eq i32 %89, %84
br i1 %85, label %132, label %86
86: ; preds = %81, %79
%87 = phi i32 [ 0, %79 ], [ %82, %81 ]
%88 = phi i32 [ 0, %79 ], [ %83, %81 ]
%89 = phi i32 [ 0, %79 ], [ %84, %81 ]
%90 = add i32 %88, 1
%91 = icmp ult i32 %90, %80
br i1 %91, label %92, label %81
92: ; preds = %86
%93 = zext i32 %90 to i64
br label %94
94: ; preds = %125, %92
%95 = phi i32 [ %87, %92 ], [ %126, %125 ]
%96 = phi i32 [ %88, %92 ], [ %126, %125 ]
%97 = phi i64 [ %93, %92 ], [ %129, %125 ]
%98 = phi i32 [ %89, %92 ], [ %128, %125 ]
%99 = zext i32 %96 to i64
%100 = mul nuw nsw i64 %99, %15
%101 = getelementptr inbounds i8, i8* %18, i64 %100
%102 = getelementptr inbounds i8, i8* %101, i64 %97
%103 = load i8, i8* %102
%104 = icmp eq i8 %103, 0
br i1 %104, label %125, label %105
105: ; preds = %94
%106 = getelementptr inbounds i8, i8* %18, i64 %97
br label %107
107: ; preds = %105, %111
%108 = phi i32 [ %109, %111 ], [ %98, %105 ]
%109 = add i32 %108, -1
%110 = icmp sgt i32 %109, -1
br i1 %110, label %111, label %120
111: ; preds = %107
%112 = zext i32 %109 to i64
%113 = getelementptr inbounds i32, i32* %22, i64 %112
%114 = load i32, i32* %113
%115 = zext i32 %114 to i64
%116 = mul nuw nsw i64 %115, %15
%117 = getelementptr inbounds i8, i8* %106, i64 %116
%118 = load i8, i8* %117
%119 = icmp eq i8 %118, 1
br i1 %119, label %107, label %125
120: ; preds = %107
%121 = add i32 %98, 1
%122 = zext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %22, i64 %122
%124 = trunc i64 %97 to i32
store i32 %124, i32* %123
br label %125
125: ; preds = %111, %120, %94
%126 = phi i32 [ %95, %94 ], [ %124, %120 ], [ %95, %111 ]
%127 = phi i32 [ %96, %94 ], [ %124, %120 ], [ %96, %111 ]
%128 = phi i32 [ %98, %94 ], [ %121, %120 ], [ %98, %111 ]
%129 = add nuw nsw i64 %97, 1
%130 = trunc i64 %129 to i32
%131 = icmp ugt i32 %80, %130
br i1 %131, label %94, label %81
132: ; preds = %81
%133 = add i32 %89, 1
store i32 %133, i32* %1
%134 = zext i32 %133 to i64
%135 = shl nuw nsw i64 %134, 3
%136 = call i8* @malloc(i64 %135)
%137 = bitcast i8* %136 to i32**
%138 = add i32 %4, -1
%139 = zext i32 %138 to i64
%140 = shl nuw nsw i64 %139, 2
%141 = mul i64 %140, %134
%142 = call i8* @malloc(i64 %141)
%143 = bitcast i8* %142 to i32*
%144 = icmp eq i32 %133, 0
br i1 %144, label %295, label %145
145: ; preds = %132
%146 = icmp eq i32 %138, 0
%147 = shl nuw nsw i64 %139, 2
%148 = getelementptr i8, i8* %142, i64 %147
%149 = and i64 %139, 4294967288
%150 = add nsw i64 %149, -8
%151 = lshr exact i64 %150, 3
%152 = add nuw nsw i64 %151, 1
%153 = icmp ult i32 %138, 8
%154 = and i64 %139, 4294967288
%155 = and i64 %152, 3
%156 = icmp ult i64 %150, 24
%157 = and i64 %152, 4611686018427387900
%158 = icmp eq i64 %155, 0
%159 = icmp eq i64 %154, %139
%160 = and i64 %139, 3
%161 = icmp eq i64 %160, 0
br label %162
162: ; preds = %145, %292
%163 = phi i64 [ 0, %145 ], [ %293, %292 ]
%164 = trunc i64 %163 to i32
%165 = mul i32 %138, %164
%166 = zext i32 %165 to i64
%167 = shl nuw nsw i64 %166, 2
%168 = getelementptr i8, i8* %142, i64 %167
%169 = getelementptr i8, i8* %148, i64 %167
%170 = trunc i64 %163 to i32
%171 = mul i32 %138, %170
%172 = zext i32 %171 to i64
%173 = getelementptr inbounds i32, i32* %143, i64 %172
%174 = getelementptr inbounds i32*, i32** %137, i64 %163
store i32* %173, i32** %174
br i1 %146, label %292, label %175
175: ; preds = %162
%176 = getelementptr inbounds i32, i32* %22, i64 %163
%177 = load i32, i32* %176
%178 = zext i32 %177 to i64
%179 = getelementptr inbounds i32*, i32** %8, i64 %178
%180 = load i32*, i32** %179
br i1 %153, label %257, label %181
181: ; preds = %175
%182 = bitcast i32* %180 to i8*
%183 = getelementptr i32, i32* %180, i64 %139
%184 = bitcast i32* %183 to i8*
%185 = icmp ult i8* %168, %184
%186 = icmp ugt i8* %169, %182
%187 = and i1 %185, %186
br i1 %187, label %257, label %188
188: ; preds = %181
br i1 %156, label %238, label %189
189: ; preds = %188, %189
%190 = phi i64 [ %235, %189 ], [ 0, %188 ]
%191 = phi i64 [ %236, %189 ], [ 0, %188 ]
%192 = getelementptr inbounds i32, i32* %180, i64 %190
%193 = bitcast i32* %192 to <4 x i32>*
%194 = load <4 x i32>, <4 x i32>* %193
%195 = getelementptr inbounds i32, i32* %192, i64 4
%196 = bitcast i32* %195 to <4 x i32>*
%197 = load <4 x i32>, <4 x i32>* %196
%198 = getelementptr inbounds i32, i32* %173, i64 %190
%199 = bitcast i32* %198 to <4 x i32>*
store <4 x i32> %194, <4 x i32>* %199
%200 = getelementptr inbounds i32, i32* %198, i64 4
%201 = bitcast i32* %200 to <4 x i32>*
store <4 x i32> %197, <4 x i32>* %201
%202 = or i64 %190, 8
%203 = getelementptr inbounds i32, i32* %180, i64 %202
%204 = bitcast i32* %203 to <4 x i32>*
%205 = load <4 x i32>, <4 x i32>* %204
%206 = getelementptr inbounds i32, i32* %203, i64 4
%207 = bitcast i32* %206 to <4 x i32>*
%208 = load <4 x i32>, <4 x i32>* %207
%209 = getelementptr inbounds i32, i32* %173, i64 %202
%210 = bitcast i32* %209 to <4 x i32>*
store <4 x i32> %205, <4 x i32>* %210
%211 = getelementptr inbounds i32, i32* %209, i64 4
%212 = bitcast i32* %211 to <4 x i32>*
store <4 x i32> %208, <4 x i32>* %212
%213 = or i64 %190, 16
%214 = getelementptr inbounds i32, i32* %180, i64 %213
%215 = bitcast i32* %214 to <4 x i32>*
%216 = load <4 x i32>, <4 x i32>* %215
%217 = getelementptr inbounds i32, i32* %214, i64 4
%218 = bitcast i32* %217 to <4 x i32>*
%219 = load <4 x i32>, <4 x i32>* %218
%220 = getelementptr inbounds i32, i32* %173, i64 %213
%221 = bitcast i32* %220 to <4 x i32>*
store <4 x i32> %216, <4 x i32>* %221
%222 = getelementptr inbounds i32, i32* %220, i64 4
%223 = bitcast i32* %222 to <4 x i32>*
store <4 x i32> %219, <4 x i32>* %223
%224 = or i64 %190, 24
%225 = getelementptr inbounds i32, i32* %180, i64 %224
%226 = bitcast i32* %225 to <4 x i32>*
%227 = load <4 x i32>, <4 x i32>* %226
%228 = getelementptr inbounds i32, i32* %225, i64 4
%229 = bitcast i32* %228 to <4 x i32>*
%230 = load <4 x i32>, <4 x i32>* %229
%231 = getelementptr inbounds i32, i32* %173, i64 %224
%232 = bitcast i32* %231 to <4 x i32>*
store <4 x i32> %227, <4 x i32>* %232
%233 = getelementptr inbounds i32, i32* %231, i64 4
%234 = bitcast i32* %233 to <4 x i32>*
store <4 x i32> %230, <4 x i32>* %234
%235 = add nuw i64 %190, 32
%236 = add i64 %191, 4
%237 = icmp eq i64 %236, %157
br i1 %237, label %238, label %189
238: ; preds = %189, %188
%239 = phi i64 [ 0, %188 ], [ %235, %189 ]
br i1 %158, label %256, label %240
240: ; preds = %238, %240
%241 = phi i64 [ %253, %240 ], [ %239, %238 ]
%242 = phi i64 [ %254, %240 ], [ 0, %238 ]
%243 = getelementptr inbounds i32, i32* %180, i64 %241
%244 = bitcast i32* %243 to <4 x i32>*
%245 = load <4 x i32>, <4 x i32>* %244
%246 = getelementptr inbounds i32, i32* %243, i64 4
%247 = bitcast i32* %246 to <4 x i32>*
%248 = load <4 x i32>, <4 x i32>* %247
%249 = getelementptr inbounds i32, i32* %173, i64 %241
%250 = bitcast i32* %249 to <4 x i32>*
store <4 x i32> %245, <4 x i32>* %250
%251 = getelementptr inbounds i32, i32* %249, i64 4
%252 = bitcast i32* %251 to <4 x i32>*
store <4 x i32> %248, <4 x i32>* %252
%253 = add nuw i64 %241, 8
%254 = add i64 %242, 1
%255 = icmp eq i64 %254, %155
br i1 %255, label %256, label %240
256: ; preds = %240, %238
br i1 %159, label %292, label %257
257: ; preds = %181, %175, %256
%258 = phi i64 [ 0, %181 ], [ 0, %175 ], [ %154, %256 ]
%259 = xor i64 %258, -1
%260 = add nsw i64 %259, %139
br i1 %161, label %270, label %261
261: ; preds = %257, %261
%262 = phi i64 [ %267, %261 ], [ %258, %257 ]
%263 = phi i64 [ %268, %261 ], [ 0, %257 ]
%264 = getelementptr inbounds i32, i32* %180, i64 %262
%265 = load i32, i32* %264
%266 = getelementptr inbounds i32, i32* %173, i64 %262
store i32 %265, i32* %266
%267 = add nuw nsw i64 %262, 1
%268 = add i64 %263, 1
%269 = icmp eq i64 %268, %160
br i1 %269, label %270, label %261
270: ; preds = %261, %257
%271 = phi i64 [ %258, %257 ], [ %267, %261 ]
%272 = icmp ult i64 %260, 3
br i1 %272, label %292, label %273
273: ; preds = %270, %273
%274 = phi i64 [ %290, %273 ], [ %271, %270 ]
%275 = getelementptr inbounds i32, i32* %180, i64 %274
%276 = load i32, i32* %275
%277 = getelementptr inbounds i32, i32* %173, i64 %274
store i32 %276, i32* %277
%278 = add nuw nsw i64 %274, 1
%279 = getelementptr inbounds i32, i32* %180, i64 %278
%280 = load i32, i32* %279
%281 = getelementptr inbounds i32, i32* %173, i64 %278
store i32 %280, i32* %281
%282 = add nuw nsw i64 %274, 2
%283 = getelementptr inbounds i32, i32* %180, i64 %282
%284 = load i32, i32* %283
%285 = getelementptr inbounds i32, i32* %173, i64 %282
store i32 %284, i32* %285
%286 = add nuw nsw i64 %274, 3
%287 = getelementptr inbounds i32, i32* %180, i64 %286
%288 = load i32, i32* %287
%289 = getelementptr inbounds i32, i32* %173, i64 %286
store i32 %288, i32* %289
%290 = add nuw nsw i64 %274, 4
%291 = icmp eq i64 %290, %139
br i1 %291, label %292, label %273
292: ; preds = %270, %273, %256, %162
%293 = add nuw nsw i64 %163, 1
%294 = icmp eq i64 %293, %134
br i1 %294, label %295, label %162
295: ; preds = %292, %132
%296 = inttoptr i64 %7 to i8**
%297 = load i8*, i8** %296
%298 = inttoptr i64 %7 to i8*
ret i32** %137
}