#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ malloc(int);
int **faure_permutation(int n) {
  int i, j, c;
  int **p;
  if (n < 2)
    return NULL;
  p = (int **)malloc(sizeof(int *) * (n + 1));
  for (i = 1; i < n + 1; i++) {
    p[i] = (int *)malloc(sizeof(int) * (i + 1));
  }
  p[0] = NULL;
  p[1][0] = 0;
  p[1][1] = 1;
  for (i = 3; i < n + 1; i++) {
    if (i % 2 != 0) {
      for (j = 0; j < (i - 1) / 2; j++) {
        if (2 * p[i - 2][j] >= i - 1) {
          p[i - 1][j] = p[i - 2][j] + 1;
        } else {
          p[i - 1][j] = p[i - 2][j];
        }
      }
      c = (int)((i - 1) / 2);
      p[i - 1][c] = c;
      for (j = (i - 1) / 2 + 1; j < i; j++) {
        if (2 * p[i - 2][j - 1] >= i - 1) {
          p[i - 1][j] = p[i - 2][j - 1] + 1;
        } else {
          p[i - 1][j] = p[i - 2][j - 1];
        }
      }
    } else {
      for (j = 0; j < i / 2; j++) {
        p[i - 1][j] = 2 * p[i / 2 - 1][j];
      }
      for (j = i / 2; j < i; j++) {
        p[i - 1][j] = p[i - 1][j - i / 2] + 1;
      }
    }
  }
  return p;
}


x86 assembly (clang, -O0):
<faure_permutation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0xc(%rbp)
cmpl   $0x2,-0xc(%rbp)
jge    1132 <faure_permutation+0x22>
movq   $0x0,-0x8(%rbp)
jmp    14c1 <faure_permutation+0x3b1>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1191 <faure_permutation+0x81>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1150 <faure_permutation+0x40>
mov    -0x20(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x0,(%rax)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x1,0x4(%rax)
movl   $0x3,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14b9 <faure_permutation+0x3a9>
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     13b5 <faure_permutation+0x2a5>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x24(%rbp),%eax
cmp    %ecx,%eax
jge    12b1 <faure_permutation+0x1a1>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x1,%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     126e <faure_permutation+0x15e>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    129e <faure_permutation+0x18e>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12a3 <faure_permutation+0x193>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11ec <faure_permutation+0xdc>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13b0 <faure_permutation+0x2a0>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x1,%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     1368 <faure_permutation+0x258>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    139d <faure_permutation+0x28d>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    13a2 <faure_permutation+0x292>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12f1 <faure_permutation+0x1e1>
jmp    14a6 <faure_permutation+0x396>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x28(%rbp),%eax
cmp    %ecx,%eax
jge    142d <faure_permutation+0x31d>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
shl    $0x1,%edx
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13bc <faure_permutation+0x2ac>
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14a1 <faure_permutation+0x391>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x10(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x38(%rbp),%rax
sub    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    143b <faure_permutation+0x32b>
jmp    14a6 <faure_permutation+0x396>
jmp    14ab <faure_permutation+0x39b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11c0 <faure_permutation+0xb0>
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<faure_permutation>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
cmp    $0x2,%edi
jge    1125 <faure_permutation+0x15>
xor    %r15d,%r15d
jmp    1188 <faure_permutation+0x78>
mov    %edi,%eax
lea    0x8(,%rax,8),%edi
mov    %rax,%rbx
call   1030 <malloc@plt>
mov    %rax,%r15
mov    %rbx,%r12
mov    %ebx,%eax
lea    0x4(,%rax,4),%r14
mov    $0x4,%ebx
nopl   0x0(%rax,%rax,1)
lea    0x4(%rbx),%rbp
mov    %ebp,%edi
call   1030 <malloc@plt>
mov    %rax,(%r15,%rbx,2)
mov    %rbp,%rbx
cmp    %rbp,%r14
jne    1150 <faure_permutation+0x40>
movq   $0x0,(%r15)
mov    0x8(%r15),%rax
movabs $0x100000000,%rcx
mov    %rcx,(%rax)
mov    %r12,%r8
cmp    $0x3,%r8d
jge    119a <faure_permutation+0x8a>
mov    %r15,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%r8d
mov    $0x2,%r13d
mov    $0x3,%r10d
mov    $0xfffffffffffffffe,%r9
pcmpeqd %xmm0,%xmm0
movdqa 0xe43(%rip),%xmm1
mov    %r8,(%rsp)
jmp    11e1 <faure_permutation+0xd1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
add    $0x1,%r13
add    $0x1,%r9
cmp    %r8,%r10
je     1188 <faure_permutation+0x78>
mov    %r10,%rbx
shr    %rbx
lea    0x1(%rbx),%r12
cmp    %r12,%r10
cmova  %r10,%r12
test   $0x1,%r10b
jne    12b0 <faure_permutation+0x1a0>
mov    %r12,%r11
sub    %rbx,%r11
mov    %r10d,%r14d
shr    %r14d
lea    -0x1(%r14),%eax
mov    (%r15,%rax,8),%rsi
mov    -0x8(%r15,%r10,8),%rdi
cmp    $0x10,%r10
jb     1235 <faure_permutation+0x125>
lea    (%rsi,%rbx,4),%rax
cmp    %rax,%rdi
jae    13be <faure_permutation+0x2ae>
lea    (%rdi,%rbx,4),%rax
cmp    %rax,%rsi
jae    13be <faure_permutation+0x2ae>
xor    %eax,%eax
mov    %rax,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%bl
je     1262 <faure_permutation+0x152>
mov    %ebx,%ecx
and    $0x3,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rax,4),%ebp
add    %ebp,%ebp
mov    %ebp,(%rdi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    1250 <faure_permutation+0x140>
cmp    $0x3,%rdx
jb     1480 <faure_permutation+0x370>
nopl   0x0(%rax)
mov    (%rsi,%rax,4),%ecx
add    %ecx,%ecx
mov    %ecx,(%rdi,%rax,4)
mov    0x4(%rsi,%rax,4),%ecx
add    %ecx,%ecx
mov    %ecx,0x4(%rdi,%rax,4)
mov    0x8(%rsi,%rax,4),%ecx
add    %ecx,%ecx
mov    %ecx,0x8(%rdi,%rax,4)
mov    0xc(%rsi,%rax,4),%ecx
add    %ecx,%ecx
mov    %ecx,0xc(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbx
jne    1270 <faure_permutation+0x160>
jmp    1480 <faure_permutation+0x370>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13,%r12
shr    %r12
lea    -0x1(%r10),%r11
mov    -0x10(%r15,%r10,8),%rax
cmp    $0x1,%r12
jne    12d0 <faure_permutation+0x1c0>
xor    %edx,%edx
jmp    131b <faure_permutation+0x20b>
nopl   0x0(%rax)
mov    %r12,%rcx
and    $0xfffffffffffffffe,%rcx
mov    -0x8(%r15,%r10,8),%rbx
xor    %edx,%edx
xchg   %ax,%ax
movslq (%rax,%rdx,4),%rbp
mov    %rbp,%rsi
add    %rbp,%rsi
xor    %edi,%edi
cmp    %rsi,%r11
setle  %dil
add    %ebp,%edi
mov    %edi,(%rbx,%rdx,4)
movslq 0x4(%rax,%rdx,4),%rsi
mov    %rsi,%rdi
add    %rsi,%rdi
xor    %ebp,%ebp
cmp    %rdi,%r11
setle  %bpl
add    %esi,%ebp
mov    %ebp,0x4(%rbx,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    12e0 <faure_permutation+0x1d0>
mov    %r11d,%ecx
shr    %ecx
test   $0x2,%r13b
je     1343 <faure_permutation+0x233>
movslq (%rax,%rdx,4),%rax
mov    %rax,%rsi
add    %rax,%rsi
xor    %edi,%edi
cmp    %rsi,%r11
setle  %dil
add    %eax,%edi
mov    -0x8(%r15,%r10,8),%rbx
mov    %edi,(%rbx,%rdx,4)
mov    %ecx,%eax
mov    %ecx,(%rbx,%rax,4)
add    $0x1,%ecx
cmp    %rcx,%r10
jbe    11d0 <faure_permutation+0xc0>
mov    %r13,%rdi
sub    %r12,%rdi
lea    0x1(%r12),%rsi
mov    -0x10(%r15,%r10,8),%rcx
cmp    $0x4,%rdi
jb     17c0 <faure_permutation+0x6b0>
lea    (%rbx,%r12,4),%rax
add    $0x4,%rax
lea    (%rcx,%r13,4),%rdx
cmp    %rdx,%rax
jae    1390 <faure_permutation+0x280>
lea    (%rbx,%r10,4),%rax
lea    (%rcx,%r12,4),%rdx
cmp    %rax,%rdx
jb     17c0 <faure_permutation+0x6b0>
lea    -0x4(%rdi),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
movq   %r11,%xmm2
pshufd $0x44,%xmm2,%xmm2
pxor   %xmm1,%xmm2
cmp    $0x4,%rax
jae    15a8 <faure_permutation+0x498>
xor    %eax,%eax
jmp    16fe <faure_permutation+0x5ee>
mov    %rbx,%rax
movabs $0x3ffffffffffffff8,%rcx
ff ff 3f
and    %rcx,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1597 <faure_permutation+0x487>
mov    %rbx,%rdx
and    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ebp,%ebp
nop
movdqu (%rsi,%rbp,4),%xmm2
movdqu 0x10(%rsi,%rbp,4),%xmm3
paddd  %xmm2,%xmm2
paddd  %xmm3,%xmm3
movdqu %xmm2,(%rdi,%rbp,4)
movdqu %xmm3,0x10(%rdi,%rbp,4)
movdqu 0x20(%rsi,%rbp,4),%xmm2
movdqu 0x30(%rsi,%rbp,4),%xmm3
paddd  %xmm2,%xmm2
paddd  %xmm3,%xmm3
movdqu %xmm2,0x20(%rdi,%rbp,4)
movdqu %xmm3,0x30(%rdi,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1400 <faure_permutation+0x2f0>
test   $0x1,%r8b
je     146c <faure_permutation+0x35c>
movdqu (%rsi,%rbp,4),%xmm2
movdqu 0x10(%rsi,%rbp,4),%xmm3
paddd  %xmm2,%xmm2
paddd  %xmm3,%xmm3
movdqu %xmm2,(%rdi,%rbp,4)
movdqu %xmm3,0x10(%rdi,%rbp,4)
cmp    %rax,%rbx
mov    (%rsp),%r8
jne    1237 <faure_permutation+0x127>
nopl   0x0(%rax)
mov    %rbx,%rsi
cmp    $0x8,%r11
jb     1570 <faure_permutation+0x460>
lea    (%rdi,%rbx,4),%rax
lea    (%rdi,%r11,4),%rcx
cmp    %rcx,%rax
jae    14aa <faure_permutation+0x39a>
lea    (%rdi,%r12,4),%rax
mov    %rbx,%rsi
cmp    %rax,%rdi
jb     1570 <faure_permutation+0x460>
lea    -0x8(%r11),%rax
mov    %rax,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
cmp    $0x8,%rax
jae    14c3 <faure_permutation+0x3b3>
xor    %eax,%eax
jmp    1528 <faure_permutation+0x418>
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rdi,%rbx,4),%rsi
add    $0x30,%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rdi,%rax,4),%xmm2
movdqu 0x10(%rdi,%rax,4),%xmm3
psubd  %xmm0,%xmm2
psubd  %xmm0,%xmm3
movdqu %xmm2,-0x30(%rsi,%rax,4)
movdqu %xmm3,-0x20(%rsi,%rax,4)
movdqu 0x20(%rdi,%rax,4),%xmm2
movdqu 0x30(%rdi,%rax,4),%xmm3
psubd  %xmm0,%xmm2
psubd  %xmm0,%xmm3
movdqu %xmm2,-0x10(%rsi,%rax,4)
movdqu %xmm3,(%rsi,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    14e0 <faure_permutation+0x3d0>
mov    %r11,%rsi
and    $0xfffffffffffffff8,%rsi
test   $0x1,%bpl
je     155f <faure_permutation+0x44f>
mov    %r14d,%ecx
add    %rbx,%rax
mov    %rax,%rdx
sub    %rcx,%rdx
movdqu (%rdi,%rdx,4),%xmm2
movdqu 0x10(%rdi,%rdx,4),%xmm3
psubd  %xmm0,%xmm2
psubd  %xmm0,%xmm3
movdqu %xmm2,(%rdi,%rax,4)
movdqu %xmm3,0x10(%rdi,%rax,4)
cmp    %rsi,%r11
je     11d0 <faure_permutation+0xc0>
add    %rbx,%rsi
nopl   0x0(%rax,%rax,1)
neg    %rbx
lea    (%rdi,%rbx,4),%rax
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rsi,4),%ecx
add    $0x1,%ecx
mov    %ecx,(%rdi,%rsi,4)
add    $0x1,%rsi
cmp    %r10,%rsi
jb     1580 <faure_permutation+0x470>
jmp    11d0 <faure_permutation+0xc0>
xor    %ebp,%ebp
test   $0x1,%r8b
jne    144e <faure_permutation+0x33e>
jmp    146c <faure_permutation+0x35c>
mov    %r9,%rbp
sub    %r12,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rcx,%r12,4),%r8
add    $0x10,%r8
lea    (%rbx,%r12,4),%r14
add    $0x14,%r14
xor    %eax,%eax
nopl   0x0(%rax)
movdqu -0x10(%r8,%rax,4),%xmm3
movdqa %xmm3,%xmm4
paddd  %xmm3,%xmm4
pshufd $0xee,%xmm4,%xmm5
pxor   %xmm6,%xmm6
pcmpgtd %xmm5,%xmm6
punpckldq %xmm6,%xmm5
pxor   %xmm6,%xmm6
pcmpgtd %xmm4,%xmm6
punpckldq %xmm6,%xmm4
pxor   %xmm1,%xmm4
movdqa %xmm2,%xmm6
pcmpgtd %xmm4,%xmm6
pshufd $0xa0,%xmm6,%xmm7
pcmpeqd %xmm2,%xmm4
pshufd $0xf5,%xmm4,%xmm4
pand   %xmm7,%xmm4
pshufd $0xf5,%xmm6,%xmm6
por    %xmm4,%xmm6
pxor   %xmm0,%xmm6
pxor   %xmm1,%xmm5
movdqa %xmm2,%xmm4
pcmpgtd %xmm5,%xmm4
pshufd $0xa0,%xmm4,%xmm7
pcmpeqd %xmm2,%xmm5
pshufd $0xf5,%xmm5,%xmm5
pand   %xmm7,%xmm5
pshufd $0xf5,%xmm4,%xmm4
por    %xmm5,%xmm4
pxor   %xmm0,%xmm4
packssdw %xmm4,%xmm6
psubd  %xmm6,%xmm3
movdqu %xmm3,-0x10(%r14,%rax,4)
movdqu (%r8,%rax,4),%xmm3
movdqa %xmm3,%xmm4
paddd  %xmm3,%xmm4
pshufd $0xee,%xmm4,%xmm5
pxor   %xmm6,%xmm6
pcmpgtd %xmm5,%xmm6
punpckldq %xmm6,%xmm5
pxor   %xmm6,%xmm6
pcmpgtd %xmm4,%xmm6
punpckldq %xmm6,%xmm4
pxor   %xmm1,%xmm4
movdqa %xmm2,%xmm6
pcmpgtd %xmm4,%xmm6
pshufd $0xa0,%xmm6,%xmm7
pcmpeqd %xmm2,%xmm4
pshufd $0xf5,%xmm4,%xmm4
pand   %xmm7,%xmm4
pshufd $0xf5,%xmm6,%xmm6
por    %xmm4,%xmm6
pxor   %xmm0,%xmm6
pxor   %xmm1,%xmm5
movdqa %xmm2,%xmm4
pcmpgtd %xmm5,%xmm4
pshufd $0xa0,%xmm4,%xmm7
pcmpeqd %xmm2,%xmm5
pshufd $0xf5,%xmm5,%xmm5
pand   %xmm7,%xmm5
pshufd $0xf5,%xmm4,%xmm4
por    %xmm5,%xmm4
pxor   %xmm0,%xmm4
packssdw %xmm4,%xmm6
psubd  %xmm6,%xmm3
movdqu %xmm3,(%r14,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    15d0 <faure_permutation+0x4c0>
mov    %rdi,%rbp
and    $0xfffffffffffffffc,%rbp
test   $0x1,%dl
je     17a2 <faure_permutation+0x692>
lea    (%r12,%rax,1),%rdx
add    %rsi,%rax
movdqu (%rcx,%rdx,4),%xmm3
movdqa %xmm3,%xmm4
paddd  %xmm3,%xmm4
pshufd $0xee,%xmm4,%xmm5
pxor   %xmm6,%xmm6
pcmpgtd %xmm5,%xmm6
punpckldq %xmm6,%xmm5
pxor   %xmm6,%xmm6
pcmpgtd %xmm4,%xmm6
punpckldq %xmm6,%xmm4
pxor   %xmm1,%xmm4
movdqa %xmm2,%xmm6
pcmpgtd %xmm4,%xmm6
pshufd $0xa0,%xmm6,%xmm7
pcmpeqd %xmm2,%xmm4
pshufd $0xf5,%xmm4,%xmm4
pand   %xmm7,%xmm4
pshufd $0xf5,%xmm6,%xmm6
por    %xmm4,%xmm6
pxor   %xmm0,%xmm6
pxor   %xmm1,%xmm5
movdqa %xmm2,%xmm4
pcmpgtd %xmm5,%xmm4
pshufd $0xa0,%xmm4,%xmm7
pcmpeqd %xmm2,%xmm5
pshufd $0xf5,%xmm5,%xmm2
pand   %xmm7,%xmm2
pshufd $0xf5,%xmm4,%xmm4
por    %xmm2,%xmm4
pxor   %xmm0,%xmm4
packssdw %xmm4,%xmm6
psubd  %xmm6,%xmm3
movdqu %xmm3,(%rbx,%rax,4)
cmp    %rbp,%rdi
mov    (%rsp),%r8
je     11d0 <faure_permutation+0xc0>
add    %rbp,%r12
add    %rbp,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rcx,%r12,4),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq (%rax),%rcx
mov    %rcx,%rdx
add    %rcx,%rdx
xor    %edi,%edi
cmp    %rdx,%r11
setle  %dil
add    %ecx,%edi
mov    %edi,(%rbx,%rsi,4)
add    $0x1,%rsi
add    $0x4,%rax
cmp    %r10,%rsi
jb     17d0 <faure_permutation+0x6c0>
jmp    11d0 <faure_permutation+0xc0>

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

LLVM IR (-O2):
define i32** @faure_permutation(i32 %0) {
%2 = icmp slt i32 %0, 2
br i1 %2, label %417, label %3
3: ; preds = %1
%4 = shl i32 %0, 3
%5 = add i32 %4, 8
%6 = tail call i64 @malloc(i32 %5)
%7 = inttoptr i64 %6 to i32**
%8 = add nuw i32 %0, 1
%9 = zext i32 %8 to i64
br label %10
10: ; preds = %3, %10
%11 = phi i64 [ 1, %3 ], [ %12, %10 ]
%12 = add nuw nsw i64 %11, 1
%13 = trunc i64 %12 to i32
%14 = shl i32 %13, 2
%15 = tail call i64 @malloc(i32 %14)
%16 = inttoptr i64 %15 to i32*
%17 = getelementptr inbounds i32*, i32** %7, i64 %11
store i32* %16, i32** %17
%18 = icmp eq i64 %12, %9
br i1 %18, label %19, label %10
19: ; preds = %10
store i32* null, i32** %7
%20 = getelementptr inbounds i32*, i32** %7, i64 1
%21 = load i32*, i32** %20
store i32 0, i32* %21
%22 = getelementptr inbounds i32, i32* %21, i64 1
store i32 1, i32* %22
%23 = icmp slt i32 %0, 3
br i1 %23, label %417, label %24
24: ; preds = %19
%25 = add nuw i32 %0, 1
%26 = zext i32 %25 to i64
br label %27
27: ; preds = %24, %413
%28 = phi i64 [ 3, %24 ], [ %414, %413 ]
%29 = phi i64 [ 2, %24 ], [ %415, %413 ]
%30 = lshr i64 %28, 1
%31 = add nuw nsw i64 %30, 1
%32 = call i64 @llvm.umax.i64(i64 %28, i64 %31)
%33 = sub nsw i64 %32, %30
%34 = add i64 %33, -8
%35 = lshr i64 %34, 3
%36 = add nuw nsw i64 %35, 1
%37 = lshr i64 %28, 1
%38 = lshr i64 %28, 1
%39 = and i64 %38, 4611686018427387896
%40 = add nsw i64 %39, -8
%41 = lshr exact i64 %40, 3
%42 = add nuw nsw i64 %41, 1
%43 = lshr i64 %29, 1
%44 = sub nsw i64 %29, %43
%45 = add i64 %44, -4
%46 = lshr i64 %45, 2
%47 = add nuw nsw i64 %46, 1
%48 = lshr i64 %29, 1
%49 = lshr i64 %29, 1
%50 = sub nsw i64 %29, %49
%51 = lshr i64 %29, 1
%52 = lshr i64 %28, 1
%53 = lshr i64 %28, 1
%54 = lshr i64 %28, 1
%55 = add nuw nsw i64 %54, 1
%56 = call i64 @llvm.umax.i64(i64 %28, i64 %55)
%57 = sub nsw i64 %56, %54
%58 = lshr i64 %28, 1
%59 = add nuw nsw i64 %58, 1
%60 = call i64 @llvm.umax.i64(i64 %28, i64 %59)
%61 = sub nsw i64 %60, %58
%62 = lshr i64 %28, 1
%63 = trunc i64 %28 to i32
%64 = lshr i32 %63, 1
%65 = lshr i64 %29, 1
%66 = add nuw nsw i64 %65, 1
%67 = and i32 %63, 1
%68 = icmp eq i32 %67, 0
br i1 %68, label %82, label %69
69: ; preds = %27
%70 = add nsw i64 %28, -1
%71 = trunc i64 %70 to i32
%72 = lshr i32 %71, 1
%73 = add nsw i64 %28, -2
%74 = getelementptr inbounds i32*, i32** %7, i64 %73
%75 = load i32*, i32** %74
%76 = getelementptr inbounds i32*, i32** %7, i64 %70
%77 = icmp eq i64 %48, 1
br i1 %77, label %195, label %78
78: ; preds = %69
%79 = and i64 %48, 4611686018427387902
%80 = load i32*, i32** %76
%81 = load i32*, i32** %76
br label %172
82: ; preds = %27
%83 = add nsw i32 %64, -1
%84 = zext i32 %83 to i64
%85 = getelementptr inbounds i32*, i32** %7, i64 %84
%86 = load i32*, i32** %85
%87 = add nsw i64 %28, -1
%88 = getelementptr inbounds i32*, i32** %7, i64 %87
%89 = load i32*, i32** %88
%90 = zext i32 %64 to i64
%91 = icmp ult i64 %28, 16
br i1 %91, label %153, label %92
92: ; preds = %82
%93 = getelementptr i32, i32* %89, i64 %53
%94 = getelementptr i32, i32* %86, i64 %53
%95 = icmp ult i32* %89, %94
%96 = icmp ult i32* %86, %93
%97 = and i1 %95, %96
br i1 %97, label %153, label %98
98: ; preds = %92
%99 = and i64 %52, 4611686018427387896
%100 = and i64 %42, 1
%101 = icmp eq i64 %40, 0
br i1 %101, label %135, label %102
102: ; preds = %98
%103 = and i64 %42, 4611686018427387902
br label %104
104: ; preds = %104, %102
%105 = phi i64 [ 0, %102 ], [ %132, %104 ]
%106 = phi i64 [ 0, %102 ], [ %133, %104 ]
%107 = getelementptr inbounds i32, i32* %86, i64 %105
%108 = bitcast i32* %107 to <4 x i32>*
%109 = load <4 x i32>, <4 x i32>* %108
%110 = getelementptr inbounds i32, i32* %107, i64 4
%111 = bitcast i32* %110 to <4 x i32>*
%112 = load <4 x i32>, <4 x i32>* %111
%113 = shl nsw <4 x i32> %109, <i32 1, i32 1, i32 1, i32 1>
%114 = shl nsw <4 x i32> %112, <i32 1, i32 1, i32 1, i32 1>
%115 = getelementptr inbounds i32, i32* %89, i64 %105
%116 = bitcast i32* %115 to <4 x i32>*
store <4 x i32> %113, <4 x i32>* %116
%117 = getelementptr inbounds i32, i32* %115, i64 4
%118 = bitcast i32* %117 to <4 x i32>*
store <4 x i32> %114, <4 x i32>* %118
%119 = or i64 %105, 8
%120 = getelementptr inbounds i32, i32* %86, i64 %119
%121 = bitcast i32* %120 to <4 x i32>*
%122 = load <4 x i32>, <4 x i32>* %121
%123 = getelementptr inbounds i32, i32* %120, i64 4
%124 = bitcast i32* %123 to <4 x i32>*
%125 = load <4 x i32>, <4 x i32>* %124
%126 = shl nsw <4 x i32> %122, <i32 1, i32 1, i32 1, i32 1>
%127 = shl nsw <4 x i32> %125, <i32 1, i32 1, i32 1, i32 1>
%128 = getelementptr inbounds i32, i32* %89, i64 %119
%129 = bitcast i32* %128 to <4 x i32>*
store <4 x i32> %126, <4 x i32>* %129
%130 = getelementptr inbounds i32, i32* %128, i64 4
%131 = bitcast i32* %130 to <4 x i32>*
store <4 x i32> %127, <4 x i32>* %131
%132 = add nuw i64 %105, 16
%133 = add i64 %106, 2
%134 = icmp eq i64 %133, %103
br i1 %134, label %135, label %104
135: ; preds = %104, %98
%136 = phi i64 [ 0, %98 ], [ %132, %104 ]
%137 = icmp eq i64 %100, 0
br i1 %137, label %151, label %138
138: ; preds = %135
%139 = getelementptr inbounds i32, i32* %86, i64 %136
%140 = bitcast i32* %139 to <4 x i32>*
%141 = load <4 x i32>, <4 x i32>* %140
%142 = getelementptr inbounds i32, i32* %139, i64 4
%143 = bitcast i32* %142 to <4 x i32>*
%144 = load <4 x i32>, <4 x i32>* %143
%145 = shl nsw <4 x i32> %141, <i32 1, i32 1, i32 1, i32 1>
%146 = shl nsw <4 x i32> %144, <i32 1, i32 1, i32 1, i32 1>
%147 = getelementptr inbounds i32, i32* %89, i64 %136
%148 = bitcast i32* %147 to <4 x i32>*
store <4 x i32> %145, <4 x i32>* %148
%149 = getelementptr inbounds i32, i32* %147, i64 4
%150 = bitcast i32* %149 to <4 x i32>*
store <4 x i32> %146, <4 x i32>* %150
br label %151
151: ; preds = %135, %138
%152 = icmp eq i64 %52, %99
br i1 %152, label %307, label %153
153: ; preds = %92, %82, %151
%154 = phi i64 [ 0, %92 ], [ 0, %82 ], [ %99, %151 ]
%155 = xor i64 %154, -1
%156 = add nsw i64 %37, %155
%157 = and i64 %37, 3
%158 = icmp eq i64 %157, 0
br i1 %158, label %169, label %159
159: ; preds = %153, %159
%160 = phi i64 [ %166, %159 ], [ %154, %153 ]
%161 = phi i64 [ %167, %159 ], [ 0, %153 ]
%162 = getelementptr inbounds i32, i32* %86, i64 %160
%163 = load i32, i32* %162
%164 = shl nsw i32 %163, 1
%165 = getelementptr inbounds i32, i32* %89, i64 %160
store i32 %164, i32* %165
%166 = add nuw nsw i64 %160, 1
%167 = add i64 %161, 1
%168 = icmp eq i64 %167, %157
br i1 %168, label %169, label %159
169: ; preds = %159, %153
%170 = phi i64 [ %154, %153 ], [ %166, %159 ]
%171 = icmp ult i64 %156, 3
br i1 %171, label %307, label %381
172: ; preds = %172, %78
%173 = phi i64 [ 0, %78 ], [ %192, %172 ]
%174 = phi i64 [ 0, %78 ], [ %193, %172 ]
%175 = getelementptr inbounds i32, i32* %75, i64 %173
%176 = load i32, i32* %175
%177 = shl nsw i32 %176, 1
%178 = sext i32 %177 to i64
%179 = icmp sle i64 %70, %178
%180 = zext i1 %179 to i32
%181 = add nsw i32 %176, %180
%182 = getelementptr inbounds i32, i32* %80, i64 %173
store i32 %181, i32* %182
%183 = or i64 %173, 1
%184 = getelementptr inbounds i32, i32* %75, i64 %183
%185 = load i32, i32* %184
%186 = shl nsw i32 %185, 1
%187 = sext i32 %186 to i64
%188 = icmp sle i64 %70, %187
%189 = zext i1 %188 to i32
%190 = add nsw i32 %185, %189
%191 = getelementptr inbounds i32, i32* %81, i64 %183
store i32 %190, i32* %191
%192 = add nuw nsw i64 %173, 2
%193 = add i64 %174, 2
%194 = icmp eq i64 %193, %79
br i1 %194, label %195, label %172
195: ; preds = %172, %69
%196 = phi i32* [ undef, %69 ], [ %81, %172 ]
%197 = phi i64 [ 0, %69 ], [ %192, %172 ]
%198 = and i64 %29, 2
%199 = icmp eq i64 %198, 0
br i1 %199, label %210, label %200
200: ; preds = %195
%201 = getelementptr inbounds i32, i32* %75, i64 %197
%202 = load i32, i32* %201
%203 = shl nsw i32 %202, 1
%204 = sext i32 %203 to i64
%205 = icmp sle i64 %70, %204
%206 = zext i1 %205 to i32
%207 = add nsw i32 %202, %206
%208 = load i32*, i32** %76
%209 = getelementptr inbounds i32, i32* %208, i64 %197
store i32 %207, i32* %209
br label %210
210: ; preds = %195, %200
%211 = phi i32* [ %196, %195 ], [ %208, %200 ]
%212 = zext i32 %72 to i64
%213 = getelementptr inbounds i32, i32* %211, i64 %212
store i32 %72, i32* %213
%214 = add nuw nsw i32 %72, 1
%215 = zext i32 %214 to i64
%216 = icmp ugt i64 %28, %215
br i1 %216, label %217, label %413
217: ; preds = %210
%218 = add nsw i64 %28, -2
%219 = getelementptr inbounds i32*, i32** %7, i64 %218
%220 = load i32*, i32** %219
%221 = icmp ult i64 %50, 4
br i1 %221, label %290, label %222
222: ; preds = %217
%223 = getelementptr i32, i32* %211, i64 1
%224 = getelementptr i32, i32* %223, i64 %51
%225 = getelementptr i32, i32* %211, i64 %28
%226 = getelementptr i32, i32* %220, i64 %51
%227 = getelementptr i32, i32* %220, i64 %29
%228 = icmp ult i32* %224, %227
%229 = icmp ult i32* %226, %225
%230 = and i1 %228, %229
br i1 %230, label %290, label %231
231: ; preds = %222
%232 = and i64 %50, -4
%233 = add i64 %65, %232
%234 = add i64 %66, %232
%235 = insertelement <4 x i64> poison, i64 %70, i64 0
%236 = shufflevector <4 x i64> %235, <4 x i64> poison, <4 x i32> zeroinitializer
%237 = and i64 %47, 1
%238 = icmp ult i64 %45, 4
br i1 %238, label %272, label %239
239: ; preds = %231
%240 = and i64 %47, 9223372036854775806
br label %241
241: ; preds = %241, %239
%242 = phi i64 [ 0, %239 ], [ %269, %241 ]
%243 = phi i64 [ 0, %239 ], [ %270, %241 ]
%244 = add i64 %65, %242
%245 = add i64 %66, %242
%246 = getelementptr inbounds i32, i32* %220, i64 %244
%247 = bitcast i32* %246 to <4 x i32>*
%248 = load <4 x i32>, <4 x i32>* %247
%249 = shl nsw <4 x i32> %248, <i32 1, i32 1, i32 1, i32 1>
%250 = sext <4 x i32> %249 to <4 x i64>
%251 = icmp sle <4 x i64> %236, %250
%252 = zext <4 x i1> %251 to <4 x i32>
%253 = add nsw <4 x i32> %248, %252
%254 = getelementptr inbounds i32, i32* %211, i64 %245
%255 = bitcast i32* %254 to <4 x i32>*
store <4 x i32> %253, <4 x i32>* %255
%256 = or i64 %242, 4
%257 = add i64 %65, %256
%258 = add i64 %66, %256
%259 = getelementptr inbounds i32, i32* %220, i64 %257
%260 = bitcast i32* %259 to <4 x i32>*
%261 = load <4 x i32>, <4 x i32>* %260
%262 = shl nsw <4 x i32> %261, <i32 1, i32 1, i32 1, i32 1>
%263 = sext <4 x i32> %262 to <4 x i64>
%264 = icmp sle <4 x i64> %236, %263
%265 = zext <4 x i1> %264 to <4 x i32>
%266 = add nsw <4 x i32> %261, %265
%267 = getelementptr inbounds i32, i32* %211, i64 %258
%268 = bitcast i32* %267 to <4 x i32>*
store <4 x i32> %266, <4 x i32>* %268
%269 = add nuw i64 %242, 8
%270 = add i64 %243, 2
%271 = icmp eq i64 %270, %240
br i1 %271, label %272, label %241
272: ; preds = %241, %231
%273 = phi i64 [ 0, %231 ], [ %269, %241 ]
%274 = icmp eq i64 %237, 0
br i1 %274, label %288, label %275
275: ; preds = %272
%276 = add i64 %65, %273
%277 = add i64 %66, %273
%278 = getelementptr inbounds i32, i32* %220, i64 %276
%279 = bitcast i32* %278 to <4 x i32>*
%280 = load <4 x i32>, <4 x i32>* %279
%281 = shl nsw <4 x i32> %280, <i32 1, i32 1, i32 1, i32 1>
%282 = sext <4 x i32> %281 to <4 x i64>
%283 = icmp sle <4 x i64> %236, %282
%284 = zext <4 x i1> %283 to <4 x i32>
%285 = add nsw <4 x i32> %280, %284
%286 = getelementptr inbounds i32, i32* %211, i64 %277
%287 = bitcast i32* %286 to <4 x i32>*
store <4 x i32> %285, <4 x i32>* %287
br label %288
288: ; preds = %272, %275
%289 = icmp eq i64 %50, %232
br i1 %289, label %413, label %290
290: ; preds = %222, %217, %288
%291 = phi i64 [ %65, %222 ], [ %65, %217 ], [ %233, %288 ]
%292 = phi i64 [ %66, %222 ], [ %66, %217 ], [ %234, %288 ]
br label %293
293: ; preds = %290, %293
%294 = phi i64 [ %306, %293 ], [ %291, %290 ]
%295 = phi i64 [ %304, %293 ], [ %292, %290 ]
%296 = getelementptr inbounds i32, i32* %220, i64 %294
%297 = load i32, i32* %296
%298 = shl nsw i32 %297, 1
%299 = sext i32 %298 to i64
%300 = icmp sle i64 %70, %299
%301 = zext i1 %300 to i32
%302 = add nsw i32 %297, %301
%303 = getelementptr inbounds i32, i32* %211, i64 %295
store i32 %302, i32* %303
%304 = add nuw nsw i64 %295, 1
%305 = icmp ult i64 %304, %28
%306 = add nuw nsw i64 %294, 1
br i1 %305, label %293, label %413
307: ; preds = %169, %381, %151
%308 = zext i32 %64 to i64
%309 = icmp ult i64 %57, 8
br i1 %309, label %379, label %310
310: ; preds = %307
%311 = getelementptr i32, i32* %89, i64 %58
%312 = getelementptr i32, i32* %89, i64 %60
%313 = getelementptr i32, i32* %89, i64 %61
%314 = icmp ult i32* %311, %313
%315 = icmp ult i32* %89, %312
%316 = and i1 %314, %315
br i1 %316, label %379, label %317
317: ; preds = %310
%318 = and i64 %57, -8
%319 = add i64 %62, %318
%320 = and i64 %36, 1
%321 = icmp ult i64 %34, 8
br i1 %321, label %359, label %322
322: ; preds = %317
%323 = and i64 %36, 4611686018427387902
br label %324
324: ; preds = %324, %322
%325 = phi i64 [ 0, %322 ], [ %356, %324 ]
%326 = phi i64 [ 0, %322 ], [ %357, %324 ]
%327 = add i64 %62, %325
%328 = sub nuw nsw i64 %327, %308
%329 = getelementptr inbounds i32, i32* %89, i64 %328
%330 = bitcast i32* %329 to <4 x i32>*
%331 = load <4 x i32>, <4 x i32>* %330
%332 = getelementptr inbounds i32, i32* %329, i64 4
%333 = bitcast i32* %332 to <4 x i32>*
%334 = load <4 x i32>, <4 x i32>* %333
%335 = add nsw <4 x i32> %331, <i32 1, i32 1, i32 1, i32 1>
%336 = add nsw <4 x i32> %334, <i32 1, i32 1, i32 1, i32 1>
%337 = getelementptr inbounds i32, i32* %89, i64 %327
%338 = bitcast i32* %337 to <4 x i32>*
store <4 x i32> %335, <4 x i32>* %338
%339 = getelementptr inbounds i32, i32* %337, i64 4
%340 = bitcast i32* %339 to <4 x i32>*
store <4 x i32> %336, <4 x i32>* %340
%341 = or i64 %325, 8
%342 = add i64 %62, %341
%343 = sub nuw nsw i64 %342, %308
%344 = getelementptr inbounds i32, i32* %89, i64 %343
%345 = bitcast i32* %344 to <4 x i32>*
%346 = load <4 x i32>, <4 x i32>* %345
%347 = getelementptr inbounds i32, i32* %344, i64 4
%348 = bitcast i32* %347 to <4 x i32>*
%349 = load <4 x i32>, <4 x i32>* %348
%350 = add nsw <4 x i32> %346, <i32 1, i32 1, i32 1, i32 1>
%351 = add nsw <4 x i32> %349, <i32 1, i32 1, i32 1, i32 1>
%352 = getelementptr inbounds i32, i32* %89, i64 %342
%353 = bitcast i32* %352 to <4 x i32>*
store <4 x i32> %350, <4 x i32>* %353
%354 = getelementptr inbounds i32, i32* %352, i64 4
%355 = bitcast i32* %354 to <4 x i32>*
store <4 x i32> %351, <4 x i32>* %355
%356 = add nuw i64 %325, 16
%357 = add i64 %326, 2
%358 = icmp eq i64 %357, %323
br i1 %358, label %359, label %324
359: ; preds = %324, %317
%360 = phi i64 [ 0, %317 ], [ %356, %324 ]
%361 = icmp eq i64 %320, 0
br i1 %361, label %377, label %362
362: ; preds = %359
%363 = add i64 %62, %360
%364 = sub nuw nsw i64 %363, %308
%365 = getelementptr inbounds i32, i32* %89, i64 %364
%366 = bitcast i32* %365 to <4 x i32>*
%367 = load <4 x i32>, <4 x i32>* %366
%368 = getelementptr inbounds i32, i32* %365, i64 4
%369 = bitcast i32* %368 to <4 x i32>*
%370 = load <4 x i32>, <4 x i32>* %369
%371 = add nsw <4 x i32> %367, <i32 1, i32 1, i32 1, i32 1>
%372 = add nsw <4 x i32> %370, <i32 1, i32 1, i32 1, i32 1>
%373 = getelementptr inbounds i32, i32* %89, i64 %363
%374 = bitcast i32* %373 to <4 x i32>*
store <4 x i32> %371, <4 x i32>* %374
%375 = getelementptr inbounds i32, i32* %373, i64 4
%376 = bitcast i32* %375 to <4 x i32>*
store <4 x i32> %372, <4 x i32>* %376
br label %377
377: ; preds = %359, %362
%378 = icmp eq i64 %57, %318
br i1 %378, label %413, label %379
379: ; preds = %310, %307, %377
%380 = phi i64 [ %62, %310 ], [ %62, %307 ], [ %319, %377 ]
br label %404
381: ; preds = %169, %381
%382 = phi i64 [ %402, %381 ], [ %170, %169 ]
%383 = getelementptr inbounds i32, i32* %86, i64 %382
%384 = load i32, i32* %383
%385 = shl nsw i32 %384, 1
%386 = getelementptr inbounds i32, i32* %89, i64 %382
store i32 %385, i32* %386
%387 = add nuw nsw i64 %382, 1
%388 = getelementptr inbounds i32, i32* %86, i64 %387
%389 = load i32, i32* %388
%390 = shl nsw i32 %389, 1
%391 = getelementptr inbounds i32, i32* %89, i64 %387
store i32 %390, i32* %391
%392 = add nuw nsw i64 %382, 2
%393 = getelementptr inbounds i32, i32* %86, i64 %392
%394 = load i32, i32* %393
%395 = shl nsw i32 %394, 1
%396 = getelementptr inbounds i32, i32* %89, i64 %392
store i32 %395, i32* %396
%397 = add nuw nsw i64 %382, 3
%398 = getelementptr inbounds i32, i32* %86, i64 %397
%399 = load i32, i32* %398
%400 = shl nsw i32 %399, 1
%401 = getelementptr inbounds i32, i32* %89, i64 %397
store i32 %400, i32* %401
%402 = add nuw nsw i64 %382, 4
%403 = icmp eq i64 %402, %90
br i1 %403, label %307, label %381
404: ; preds = %379, %404
%405 = phi i64 [ %411, %404 ], [ %380, %379 ]
%406 = sub nuw nsw i64 %405, %308
%407 = getelementptr inbounds i32, i32* %89, i64 %406
%408 = load i32, i32* %407
%409 = add nsw i32 %408, 1
%410 = getelementptr inbounds i32, i32* %89, i64 %405
store i32 %409, i32* %410
%411 = add nuw nsw i64 %405, 1
%412 = icmp ult i64 %411, %28
br i1 %412, label %404, label %413
413: ; preds = %293, %404, %288, %377, %210
%414 = add nuw nsw i64 %28, 1
%415 = add nuw nsw i64 %29, 1
%416 = icmp eq i64 %414, %26
br i1 %416, label %417, label %27
417: ; preds = %413, %19, %1
%418 = phi i32** [ null, %1 ], [ %7, %19 ], [ %7, %413 ]
ret i32** %418
}