#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 */
int *malloc(int);
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, ...);
int fannkuch(int n) {
  int check = 0;
  int *perm;
  int *perm1;
  int *count;
  int *maxPerm;
  int maxFlipsCount = 0;
  int m = n - 1;
  int i, j, r;
  int flipsCount = 0;
  int k, k2;
  int perm0;
  int temp;
  perm = malloc(n * sizeof(int));
  memset(perm, 0, n * sizeof(int));
  perm1 = malloc(n * sizeof(int));
  memset(perm1, 0, n * sizeof(int));
  count = malloc(n * sizeof(int));
  memset(count, 0, n * sizeof(int));
  maxPerm = malloc(n * sizeof(int));
  memset(maxPerm, 0, n * sizeof(int));
  for (i = 0; i < n; ++i)
    perm1[i] = i;
  r = n;
  while (1) {
    if (check < 30) {
      for (j = 0; j < n; j++)
        printf("%d", perm1[j] + 1);
      printf("\n");
      ++check;
    }
    while (r != 1) {
      count[r - 1] = r;
      --r;
    }
    if (!(perm1[0] == 0 || perm1[m] == m)) {
      for (j = 0; j < n; j++)
        perm[j] = perm1[j];
      flipsCount = 0;
      while (!((k = perm[0]) == 0)) {
        k2 = (k + 1) >> 1;
        for (j = 0; j < k2; j++) {
          temp = perm[j];
          perm[j] = perm[k - j];
          perm[k - j] = temp;
        }
        ++flipsCount;
      }
      if (flipsCount > maxFlipsCount) {
        maxFlipsCount = flipsCount;
        for (j = 0; j < n; j++)
          maxPerm[j] = perm1[j];
      }
    }
    while (1) {
      if (r == n)
        return maxFlipsCount;
      perm0 = perm1[0];
      i = 0;
      while (i < r) {
        j = i + 1;
        perm1[i] = perm1[j];
        i = j;
      }
      perm1[r] = perm0;
      count[r] = count[r] - 1;
      if (count[r] > 0)
        break;
      ++r;
    }
  }
}


x86 assembly (clang, -O0):
<fannkuch>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x40(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1228 <fannkuch+0xf8>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1200 <fannkuch+0xd0>
mov    -0x4(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x1e,-0x8(%rbp)
jge    128c <fannkuch+0x15c>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1275 <fannkuch+0x145>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
add    $0x1,%esi
lea    0xda0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    123f <fannkuch+0x10f>
lea    0xd87(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1291 <fannkuch+0x161>
cmpl   $0x1,-0x3c(%rbp)
je     12bc <fannkuch+0x18c>
mov    -0x3c(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1291 <fannkuch+0x161>
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1403 <fannkuch+0x2d3>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
je     1403 <fannkuch+0x2d3>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1314 <fannkuch+0x1e4>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12e4 <fannkuch+0x1b4>
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
cmp    $0x0,%eax
sete   %al
xor    $0xff,%al
test   $0x1,%al
jne    1339 <fannkuch+0x209>
jmp    13b0 <fannkuch+0x280>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    13a2 <fannkuch+0x272>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    134c <fannkuch+0x21c>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    131b <fannkuch+0x1eb>
mov    -0x40(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jle    13fe <fannkuch+0x2ce>
mov    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13f9 <fannkuch+0x2c9>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13c9 <fannkuch+0x299>
jmp    13fe <fannkuch+0x2ce>
jmp    1403 <fannkuch+0x2d3>
jmp    1408 <fannkuch+0x2d8>
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    141d <fannkuch+0x2ed>
mov    -0x2c(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1463 <fannkuch+0x333>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    142d <fannkuch+0x2fd>
mov    -0x4c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    $0x1,%edx
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    14a1 <fannkuch+0x371>
jmp    14af <fannkuch+0x37f>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1408 <fannkuch+0x2d8>
jmp    122e <fannkuch+0xfe>

x86 assembly (clang, -O2):
<fannkuch>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %edi,%r15d
lea    -0x1(%r15),%r14d
lea    0x0(,%r15,4),%ebp
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1050 <memset@plt>
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,%r12
mov    %rax,0x10(%rsp)
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1050 <memset@plt>
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,%r13
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1050 <memset@plt>
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1050 <memset@plt>
mov    %r15d,%ecx
test   %r15d,%r15d
mov    %rcx,0x20(%rsp)
jle    136d <fannkuch+0x20d>
cmp    $0x8,%r15d
jae    11fa <fannkuch+0x9a>
xor    %eax,%eax
jmp    1360 <fannkuch+0x200>
mov    %ecx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1228 <fannkuch+0xc8>
movdqa 0xddf(%rip),%xmm0
xor    %esi,%esi
jmp    1300 <fannkuch+0x1a0>
and    $0xfffffffffffffffc,%rdx
movdqa 0xdcc(%rip),%xmm0
xor    %esi,%esi
movdqa 0xdd1(%rip),%xmm8
movdqa 0xdd8(%rip),%xmm9
movdqa 0xddf(%rip),%xmm10
movdqa 0xde7(%rip),%xmm4
movdqa 0xdef(%rip),%xmm5
movdqa 0xdf7(%rip),%xmm6
movdqa 0xdff(%rip),%xmm7
movdqa 0xe07(%rip),%xmm1
nopl   0x0(%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%r12,%rsi,4)
movdqu %xmm2,0x10(%r12,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%r12,%rsi,4)
movdqu %xmm3,0x30(%r12,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%r12,%rsi,4)
movdqu %xmm3,0x50(%r12,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%r12,%rsi,4)
movdqu %xmm3,0x70(%r12,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdx
jne    1280 <fannkuch+0x120>
test   %rcx,%rcx
je     1350 <fannkuch+0x1f0>
mov    0x10(%rsp),%rdx
lea    (%rdx,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movdqa 0xcf0(%rip),%xmm1
movdqa 0xcf8(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rdx,%rsi,1)
movdqu %xmm3,(%rdx,%rsi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1330 <fannkuch+0x1d0>
mov    0x20(%rsp),%rcx
cmp    %rcx,%rax
je     136d <fannkuch+0x20d>
nopw   0x0(%rax,%rax,1)
mov    %eax,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1360 <fannkuch+0x200>
movslq %r14d,%rax
mov    %rax,0x48(%rsp)
lea    0x0(,%rcx,4),%rax
mov    %rax,0x18(%rsp)
addq   $0x4,0x10(%rsp)
mov    %r13,%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,0x38(%rsp)
mov    %rbx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x58(%rsp)
mov    $0x2,%eax
sub    %rcx,%rax
mov    %rax,0x60(%rsp)
lea    0xd2c(%rip),%r14
movdqa 0xce4(%rip),%xmm3
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
or     $0x2,%rax
mov    %rax,0x30(%rsp)
movdqa 0xcd9(%rip),%xmm4
movdqa 0xce1(%rip),%xmm5
movdqa 0xce9(%rip),%xmm6
mov    %r15d,%edx
movl   $0x0,0x8(%rsp)
movl   $0x0,0xc(%rsp)
mov    %r15,0x28(%rsp)
jmp    1421 <fannkuch+0x2c1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%r15
mov    0x20(%rsp),%rcx
lea    0xcbf(%rip),%r14
cmpl   $0x1d,0xc(%rsp)
jg     1493 <fannkuch+0x333>
mov    %rdx,0x50(%rsp)
test   %r15d,%r15d
jle    145a <fannkuch+0x2fa>
mov    %rcx,%r15
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rbp,4),%esi
add    $0x1,%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1440 <fannkuch+0x2e0>
mov    $0xa,%edi
call   1030 <putchar@plt>
addl   $0x1,0xc(%rsp)
mov    0x28(%rsp),%r15
movdqa 0xc2a(%rip),%xmm3
movdqa 0xc32(%rip),%xmm4
movdqa 0xc3a(%rip),%xmm5
movdqa 0xc42(%rip),%xmm6
mov    0x50(%rsp),%rdx
cmp    $0x1,%edx
je     15a1 <fannkuch+0x441>
movslq %edx,%rax
lea    -0x2(%rdx),%ecx
cmp    $0x7,%ecx
jb     1590 <fannkuch+0x430>
add    $0x1,%rcx
mov    %rcx,%r8
and    $0xfffffffffffffff8,%r8
movd   %edx,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xbc9(%rip),%xmm0
lea    -0x8(%r8),%rdx
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     17a6 <fannkuch+0x646>
mov    %rbp,%rsi
and    0x30(%rsp),%rsi
mov    0x38(%rsp),%rdx
lea    (%rdx,%rax,4),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
pshufd $0x1b,%xmm0,%xmm2
movdqu %xmm2,(%rdx,%rdi,4)
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,-0x10(%rdx,%rdi,4)
movdqa %xmm0,%xmm1
paddd  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm5,%xmm2
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,-0x20(%rdx,%rdi,4)
pshufd $0x1b,%xmm2,%xmm1
movdqu %xmm1,-0x30(%rdx,%rdi,4)
paddd  %xmm6,%xmm0
add    $0xfffffffffffffff0,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1500 <fannkuch+0x3a0>
neg    %rdi
test   $0x1,%bpl
je     157c <fannkuch+0x41c>
not    %rdi
add    %rax,%rdi
pshufd $0x1b,%xmm0,%xmm1
paddd  %xmm3,%xmm0
movdqu %xmm1,-0xc(%r13,%rdi,4)
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm0,-0x1c(%r13,%rdi,4)
cmp    %r8,%rcx
je     15a1 <fannkuch+0x441>
sub    %r8,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,-0x4(%r13,%rax,4)
lea    -0x1(%rax),%rcx
mov    %rcx,%rax
cmp    $0x1,%ecx
jne    1590 <fannkuch+0x430>
mov    (%r12),%r9d
test   %r9d,%r9d
je     1700 <fannkuch+0x5a0>
mov    0x48(%rsp),%rax
cmp    %eax,(%r12,%rax,4)
je     1700 <fannkuch+0x5a0>
test   %r15d,%r15d
jle    15f8 <fannkuch+0x498>
mov    %rbx,%rdi
mov    %r12,%rsi
mov    0x18(%rsp),%rdx
mov    %r9d,%ebp
call   1060 <memcpy@plt>
mov    %ebp,%r9d
movdqa 0xaf0(%rip),%xmm6
movdqa 0xad8(%rip),%xmm5
movdqa 0xac0(%rip),%xmm4
movdqa 0xaa8(%rip),%xmm3
mov    (%rbx),%ecx
xor    %r14d,%r14d
jmp    1606 <fannkuch+0x4a6>
nop
mov    (%rbx),%ecx
add    $0x1,%r14d
test   %ecx,%ecx
je     16a0 <fannkuch+0x540>
test   %ecx,%ecx
jle    1602 <fannkuch+0x4a2>
lea    0x1(%rcx),%esi
shr    %esi
mov    %ecx,%eax
mov    (%rbx,%rax,4),%edx
mov    %edx,(%rbx)
mov    %ecx,(%rbx,%rax,4)
cmp    $0x1,%esi
je     1600 <fannkuch+0x4a0>
mov    %esi,%r8d
add    $0xffffffffffffffff,%r8
mov    $0x1,%edx
cmp    $0x2,%esi
je     167e <fannkuch+0x51e>
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
mov    $0x1,%edx
nop
mov    (%rbx,%rdx,4),%ebp
mov    (%rsi),%ecx
mov    %ecx,(%rbx,%rdx,4)
mov    %ebp,(%rsi)
mov    0x4(%rbx,%rdx,4),%ecx
mov    -0x4(%rsi),%ebp
mov    %ebp,0x4(%rbx,%rdx,4)
mov    %ecx,-0x4(%rsi)
add    $0xfffffffffffffff8,%rsi
lea    (%rdi,%rdx,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdx
cmp    $0x1,%rcx
jne    1650 <fannkuch+0x4f0>
test   $0x1,%r8b
je     1600 <fannkuch+0x4a0>
mov    (%rbx,%rdx,4),%ecx
sub    %rdx,%rax
mov    (%rbx,%rax,4),%esi
mov    %esi,(%rbx,%rdx,4)
mov    %ecx,(%rbx,%rax,4)
jmp    1600 <fannkuch+0x4a0>
nopl   0x0(%rax)
mov    0x8(%rsp),%eax
cmp    %eax,%r14d
cmovg  %r14d,%eax
mov    %eax,0x8(%rsp)
jle    1700 <fannkuch+0x5a0>
test   %r15d,%r15d
jle    1700 <fannkuch+0x5a0>
mov    0x40(%rsp),%rdi
mov    %r12,%rsi
mov    0x18(%rsp),%rdx
mov    %r9d,%ebp
call   1060 <memcpy@plt>
mov    %ebp,%r9d
movdqa 0x9fa(%rip),%xmm6
movdqa 0x9e2(%rip),%xmm5
movdqa 0x9ca(%rip),%xmm4
movdqa 0x9b2(%rip),%xmm3
mov    %r14d,0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x1,%r15d
je     17b7 <fannkuch+0x657>
mov    0x4(%r12),%eax
mov    %eax,(%r12)
mov    %r9d,0x4(%r12)
mov    0x4(%r13),%eax
lea    -0x1(%rax),%ecx
mov    %ecx,0x4(%r13)
mov    $0x1,%edx
cmp    $0x1,%eax
jg     1410 <fannkuch+0x2b0>
mov    $0x8,%r14d
xor    %r15d,%r15d
nopw   0x0(%rax,%rax,1)
cmp    %r15,0x60(%rsp)
je     17b7 <fannkuch+0x657>
mov    (%r12),%ebp
mov    %r12,%rdi
mov    0x10(%rsp),%rsi
mov    %r14,%rdx
call   1080 <memmove@plt>
movdqa 0x96d(%rip),%xmm6
movdqa 0x955(%rip),%xmm5
movdqa 0x93d(%rip),%xmm4
movdqa 0x925(%rip),%xmm3
mov    %ebp,(%r12,%r14,1)
mov    0x0(%r13,%r14,1),%eax
lea    -0x1(%rax),%ecx
mov    %ecx,0x0(%r13,%r14,1)
add    $0x4,%r14
add    $0xffffffffffffffff,%r15
cmp    $0x1,%eax
jle    1740 <fannkuch+0x5e0>
mov    $0x1,%edx
sub    %r15,%rdx
jmp    1410 <fannkuch+0x2b0>
xor    %edi,%edi
test   $0x1,%bpl
jne    155a <fannkuch+0x3fa>
jmp    157c <fannkuch+0x41c>
mov    0x8(%rsp),%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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