#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 abs(int);
char *check_alloc(int, int);
int /*<<< orphan*/ free(char *);
int /*<<< orphan*/ printf(char *);
int unroot(int **treer, int notu, double *lgbi, double *lgbp, double *bootvals,
           char **nom, char **list1, char **list2, int *l1, int *l2,
           double *fracroot1) {
  int i, j, j1, j2, br_a_virer = -1, bp_a_modifier = -1, bi_a_modifier = -1,
                    somme1, somme2, drapeau;
  double l;
  for (j = 0; j < notu - 2; j++)
    if (treer[0][j] != 0)
      return 1;
  for (j1 = 0; j1 < notu - 3; j1++) {
    somme1 = 0;
    for (i = 0; i < notu + 1; i++)
      somme1 += treer[i][j1];
    if (somme1 == notu - 1) {
      br_a_virer = j1;
      if (lgbp) {
        l = lgbi[j1];
        for (i = 1; i < notu + 1; i++)
          if (treer[i][j1] == 0) {
            bp_a_modifier = i;
            break;
          }
      }
      break;
    }
    for (j2 = j1 + 1; j2 < notu - 2; j2++) {
      somme2 = 0;
      for (i = 0; i < notu + 1; i++)
        somme2 += treer[i][j2];
      if (somme1 == notu - somme2) {
        drapeau = 0;
        for (i = 1; i < notu; i++)
          if (abs(treer[i][j1] - treer[i][j2]) != 1)
            drapeau = 1;
        if (drapeau == 0) {
          br_a_virer = j1;
          if (lgbi) {
            bi_a_modifier = j2;
            l = lgbi[j1];
          }
          break;
        }
      }
      if (br_a_virer != -1)
        break;
    }
    if (br_a_virer != -1)
      break;
  }
  if (l1) {
    j1 = j2 = 0;
    for (i = 1; i <= notu; i++) {
      if (treer[i][br_a_virer] == 0) {
        list1[j1] = nom[i];
        j1++;
      } else {
        list2[j2] = nom[i];
        j2++;
      }
    }
    if (j1 < 1 || j2 < 1)
      printf("probleme\n");
    *l1 = j1;
    *l2 = j2;
    if (bp_a_modifier != -1)
      *fracroot1 = lgbp[bp_a_modifier] / (lgbp[bp_a_modifier] + l);
    if (bi_a_modifier != -1)
      *fracroot1 = lgbi[bi_a_modifier] / (lgbi[bi_a_modifier] + l);
  }
  if (bp_a_modifier != -1)
    lgbp[bp_a_modifier] += l;
  if (bi_a_modifier != -1)
    lgbi[bi_a_modifier] += l;
  for (i = br_a_virer; i < notu - 3; i++) {
    if (lgbi)
      lgbi[i] = lgbi[i + 1];
    if (bootvals)
      bootvals[i] = bootvals[i + 1];
  }
  if (lgbp)
    for (i = 0; i < notu; i++)
      lgbp[i] = lgbp[i + 1];
  if (nom) {
    free(nom[0]);
    for (i = 0; i < notu; i++)
      nom[i] = nom[i + 1];
    nom[notu] = check_alloc(100 + 1, sizeof(char));
  }
  for (i = 1; i < notu + 1; i++)
    for (j = 0; j < notu - 2; j++)
      treer[i - 1][j] = treer[i][j];
  for (j = br_a_virer + 1; j < notu - 2; j++)
    for (i = 0; i < notu; i++)
      treer[i][j - 1] = treer[i][j];
  return 0;
}


x86 assembly (clang, -O0):
<unroot>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0xffffffff,-0x4c(%rbp)
movl   $0xffffffff,-0x50(%rbp)
movl   $0xffffffff,-0x54(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    11d4 <unroot+0x94>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     11c1 <unroot+0x81>
movl   $0x1,-0x4(%rbp)
jmp    17da <unroot+0x69a>
jmp    11c6 <unroot+0x86>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    118f <unroot+0x4f>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    141a <unroot+0x2da>
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1232 <unroot+0xf2>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11fa <unroot+0xba>
mov    -0x58(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    12c0 <unroot+0x180>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     12bb <unroot+0x17b>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12b6 <unroot+0x176>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    12a3 <unroot+0x163>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    12b6 <unroot+0x176>
jmp    12a8 <unroot+0x168>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    126d <unroot+0x12d>
jmp    12bb <unroot+0x17b>
jmp    141a <unroot+0x2da>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    13f8 <unroot+0x2b8>
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1320 <unroot+0x1e0>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12e8 <unroot+0x1a8>
mov    -0x58(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
cmp    %ecx,%eax
jne    13d6 <unroot+0x296>
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1399 <unroot+0x259>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
sub    (%rax,%rcx,4),%edi
call   1040 <abs@plt>
cmp    $0x1,%eax
je     1386 <unroot+0x246>
movl   $0x1,-0x60(%rbp)
jmp    138b <unroot+0x24b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    133f <unroot+0x1ff>
cmpl   $0x0,-0x60(%rbp)
jne    13d1 <unroot+0x291>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     13cc <unroot+0x28c>
mov    -0x48(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    13f8 <unroot+0x2b8>
jmp    13d6 <unroot+0x296>
cmpl   $0xffffffff,-0x4c(%rbp)
je     13e5 <unroot+0x2a5>
jmp    13f8 <unroot+0x2b8>
jmp    13ea <unroot+0x2aa>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12c9 <unroot+0x189>
cmpl   $0xffffffff,-0x4c(%rbp)
je     1407 <unroot+0x2c7>
jmp    141a <unroot+0x2da>
jmp    140c <unroot+0x2cc>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11db <unroot+0x9b>
cmpq   $0x0,0x20(%rbp)
je     155b <unroot+0x41b>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14ba <unroot+0x37a>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1486 <unroot+0x346>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    14a7 <unroot+0x367>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    14ac <unroot+0x36c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    143a <unroot+0x2fa>
cmpl   $0x1,-0x44(%rbp)
jl     14ce <unroot+0x38e>
cmpl   $0x1,-0x48(%rbp)
jge    14da <unroot+0x39a>
lea    0xb2b(%rip),%rdi
call   1050 <printf@plt>
mov    -0x44(%rbp),%ecx
mov    0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
cmpl   $0xffffffff,-0x50(%rbp)
je     1521 <unroot+0x3e1>
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  -0x68(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movsd  %xmm0,(%rax)
cmpl   $0xffffffff,-0x54(%rbp)
je     1556 <unroot+0x416>
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  -0x68(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    155b <unroot+0x41b>
cmpl   $0xffffffff,-0x50(%rbp)
je     157c <unroot+0x43c>
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0xffffffff,-0x54(%rbp)
je     159d <unroot+0x45d>
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    161b <unroot+0x4db>
cmpq   $0x0,-0x20(%rbp)
je     15de <unroot+0x49e>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpq   $0x0,-0x30(%rbp)
je     1608 <unroot+0x4c8>
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    160d <unroot+0x4cd>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15a3 <unroot+0x463>
cmpq   $0x0,-0x28(%rbp)
je     166b <unroot+0x52b>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1666 <unroot+0x526>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    162d <unroot+0x4ed>
jmp    166b <unroot+0x52b>
cmpq   $0x0,-0x38(%rbp)
je     16de <unroot+0x59e>
mov    -0x38(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16c0 <unroot+0x580>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1689 <unroot+0x549>
mov    $0x65,%edi
mov    $0x1,%esi
call   1060 <check_alloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    175a <unroot+0x61a>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1747 <unroot+0x607>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    16fd <unroot+0x5bd>
jmp    174c <unroot+0x60c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16e5 <unroot+0x5a5>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    17d3 <unroot+0x693>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17c0 <unroot+0x680>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    177b <unroot+0x63b>
jmp    17c5 <unroot+0x685>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1763 <unroot+0x623>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<unroot>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %esi,%r10d
mov    %rdi,%r15
lea    -0x2(%r10),%r14d
cmp    $0x2,%esi
mov    %r10,0x8(%rsp)
jle    1217 <unroot+0xd7>
mov    (%r15),%rax
mov    %r14d,%edi
xor    %esi,%esi
xchg   %ax,%ax
cmpl   $0x0,(%rax,%rsi,4)
jne    14cd <unroot+0x38d>
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1170 <unroot+0x30>
mov    %rdi,0x30(%rsp)
lea    -0x3(%r10),%r11d
mov    $0xffffffff,%esi
cmp    $0x4,%r10d
jl     1947 <unroot+0x807>
mov    %rdx,0x20(%rsp)
mov    %r8,0x18(%rsp)
mov    %rcx,0x50(%rsp)
mov    %r9,0x38(%rsp)
mov    %r14d,0x4(%rsp)
lea    -0x1(%r10),%eax
mov    %eax,0x64(%rsp)
mov    %r10d,%edx
lea    0x1(%rdx),%rcx
mov    %r11,0x10(%rsp)
mov    %r11d,%eax
mov    %rax,0x70(%rsp)
lea    -0x1(%rdx),%r12
mov    %ecx,%r14d
and    $0x3,%r14d
mov    %ecx,%r13d
and    $0xfffffffc,%r13d
mov    %r12,%rax
mov    %r12,0x40(%rsp)
and    $0xfffffffffffffffe,%r12
neg    %r12
mov    $0x1,%eax
mov    %rax,0x68(%rsp)
xor    %ebx,%ebx
mov    $0x1,%r9d
mov    0x30(%rsp),%r11
mov    %rcx,0x28(%rsp)
mov    %rdx,0x48(%rsp)
jmp    12fb <unroot+0x1bb>
lea    -0x3(%r10),%r11d
mov    $0xffffffff,%ebx
mov    $0xffffffff,%eax
mov    $0xffffffff,%esi
movslq %eax,%rdi
movslq %esi,%rbp
cmpq   $0x0,0xc0(%rsp)
je     1581 <unroot+0x441>
test   %r10d,%r10d
mov    %r14d,0x4(%rsp)
mov    %r8,0x18(%rsp)
mov    %rdx,0x20(%rsp)
mov    %r11,0x10(%rsp)
mov    %esi,0x30(%rsp)
mov    %rax,0x28(%rsp)
mov    %rbp,0x48(%rsp)
mov    %rdi,0x40(%rsp)
mov    %rcx,%r14
jle    14d7 <unroot+0x397>
mov    0xb8(%rsp),%rax
mov    0xb0(%rsp),%r8
movslq %ebx,%rdx
lea    0x1(%r10),%esi
xor    %r12d,%r12d
mov    $0x1,%edi
xor    %r13d,%r13d
jmp    12b8 <unroot+0x178>
cs nopw 0x0(%rax,%rax,1)
movslq %r12d,%r12
mov    %rcx,(%rax,%r12,8)
add    $0x1,%r12d
add    $0x1,%rdi
cmp    %rdi,%rsi
je     14be <unroot+0x37e>
mov    (%r15,%rdi,8),%rcx
cmpl   $0x0,(%rcx,%rdx,4)
mov    (%r9,%rdi,8),%rcx
jne    12a0 <unroot+0x160>
movslq %r13d,%r13
mov    %rcx,(%r8,%r13,8)
add    $0x1,%r13d
jmp    12ab <unroot+0x16b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addq   $0x1,0x68(%rsp)
mov    0x58(%rsp),%rbx
cmp    0x70(%rsp),%rbx
mov    0x8(%rsp),%r10
je     1a1b <unroot+0x8db>
xor    %eax,%eax
xor    %r10d,%r10d
cmp    $0x3,%edx
jb     133d <unroot+0x1fd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%rax,8),%rsi
mov    0x8(%r15,%rax,8),%rbp
add    (%rsi,%rbx,4),%r10d
add    0x0(%rbp,%rbx,4),%r10d
mov    0x10(%r15,%rax,8),%rsi
add    (%rsi,%rbx,4),%r10d
mov    0x18(%r15,%rax,8),%rsi
add    (%rsi,%rbx,4),%r10d
add    $0x4,%rax
cmp    %rax,%r13
jne    1310 <unroot+0x1d0>
test   %r14,%r14
je     1362 <unroot+0x222>
lea    (%r15,%rax,8),%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rsi,8),%rbp
add    0x0(%rbp,%rbx,4),%r10d
add    $0x1,%rsi
cmp    %rsi,%r14
jne    1350 <unroot+0x210>
cmp    0x64(%rsp),%r10d
je     19b5 <unroot+0x875>
lea    0x1(%rbx),%rax
mov    %rax,0x58(%rsp)
cmp    %r11,%rax
jae    12e0 <unroot+0x1a0>
mov    0x68(%rsp),%r8
jmp    13af <unroot+0x26f>
cs nopw 0x0(%rax,%rax,1)
test   %esi,%esi
mov    0x28(%rsp),%rcx
mov    0x48(%rsp),%rdx
je     1956 <unroot+0x816>
add    $0x1,%r8
cmp    %r11,%r8
je     12e0 <unroot+0x1a0>
xor    %eax,%eax
xor    %esi,%esi
cmp    $0x3,%edx
jb     13ed <unroot+0x2ad>
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rax,8),%rbp
mov    0x8(%r15,%rax,8),%rdi
add    0x0(%rbp,%r8,4),%esi
add    (%rdi,%r8,4),%esi
mov    0x10(%r15,%rax,8),%rdi
add    (%rdi,%r8,4),%esi
mov    0x18(%r15,%rax,8),%rdi
add    (%rdi,%r8,4),%esi
add    $0x4,%rax
cmp    %rax,%r13
jne    13c0 <unroot+0x280>
test   $0x3,%cl
je     1411 <unroot+0x2d1>
lea    (%r15,%rax,8),%rax
xor    %r11d,%r11d
nopl   0x0(%rax)
mov    (%rax,%r11,8),%rdi
add    (%rdi,%r8,4),%esi
add    $0x1,%r11
cmp    %r11,%r14
jne    1400 <unroot+0x2c0>
mov    0x8(%rsp),%rax
sub    %esi,%eax
cmp    %eax,%r10d
mov    0x30(%rsp),%r11
jne    13a2 <unroot+0x262>
cmpl   $0x2,0x8(%rsp)
jne    1440 <unroot+0x300>
xor    %esi,%esi
mov    $0x1,%eax
jmp    1495 <unroot+0x355>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %esi,%esi
mov    $0x1,%eax
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rax,8),%rdi
mov    (%rdi,%rbx,4),%ebp
sub    (%rdi,%r8,4),%ebp
mov    %ebp,%edi
neg    %edi
cmovs  %ebp,%edi
mov    0x8(%r15,%rax,8),%rbp
mov    0x0(%rbp,%rbx,4),%ecx
sub    0x0(%rbp,%r8,4),%ecx
xor    $0x1,%edi
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
xor    $0x1,%edx
or     %edi,%edx
cmovne %r9d,%esi
lea    (%r12,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
jne    1450 <unroot+0x310>
testb  $0x1,0x40(%rsp)
je     1390 <unroot+0x250>
mov    (%r15,%rax,8),%rax
mov    (%rax,%rbx,4),%ecx
sub    (%rax,%r8,4),%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    $0x1,%eax
cmovne %r9d,%esi
jmp    1390 <unroot+0x250>
mov    %r9,%rbp
test   %r13d,%r13d
jle    14e0 <unroot+0x3a0>
test   %r12d,%r12d
jg     14fd <unroot+0x3bd>
jmp    14e0 <unroot+0x3a0>
mov    $0x1,%eax
jmp    1938 <unroot+0x7f8>
mov    %r9,%rbp
xor    %r12d,%r12d
xor    %r13d,%r13d
lea    0xb19(%rip),%rdi
movsd  %xmm2,0x58(%rsp)
call   1040 <puts@plt>
movsd  0x58(%rsp),%xmm2
mov    0x8(%rsp),%r10
mov    0xd0(%rsp),%rdx
mov    0xc0(%rsp),%rax
mov    %r13d,(%rax)
mov    0xc8(%rsp),%rax
mov    %r12d,(%rax)
mov    0x28(%rsp),%rax
cmp    $0xffffffff,%eax
mov    %r14,%rcx
mov    0x40(%rsp),%rdi
je     1542 <unroot+0x402>
movsd  (%rcx,%rdi,8),%xmm0
movapd %xmm2,%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx)
mov    %rdx,%r12
mov    0x30(%rsp),%esi
cmp    $0xffffffff,%esi
mov    %rbp,%r9
mov    0x18(%rsp),%r8
mov    0x20(%rsp),%rdx
mov    0x10(%rsp),%r11
mov    0x4(%rsp),%r14d
mov    0x48(%rsp),%rbp
je     1581 <unroot+0x441>
movsd  (%rdx,%rbp,8),%xmm0
movapd %xmm2,%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r12)
cmp    $0xffffffff,%eax
je     1594 <unroot+0x454>
movsd  (%rcx,%rdi,8),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rdi,8)
cmp    $0xffffffff,%esi
je     15a3 <unroot+0x463>
addsd  (%rdx,%rbp,8),%xmm2
movsd  %xmm2,(%rdx,%rbp,8)
cmp    %r11d,%ebx
jge    15f1 <unroot+0x4b1>
movslq %ebx,%rbp
movslq %r11d,%rax
sub    %ebx,%r11d
mov    %rbp,%rsi
not    %rsi
test   $0x1,%r11b
jne    15c2 <unroot+0x482>
mov    %rbp,%rdi
jmp    15e8 <unroot+0x4a8>
test   %rdx,%rdx
je     15d2 <unroot+0x492>
movsd  0x8(%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
lea    0x1(%rbp),%rdi
test   %r8,%r8
je     15e8 <unroot+0x4a8>
movsd  0x8(%r8,%rbp,8),%xmm0
movsd  %xmm0,(%r8,%rbp,8)
add    %rax,%rsi
jne    183c <unroot+0x6fc>
test   %rcx,%rcx
je     1619 <unroot+0x4d9>
test   %r10d,%r10d
jle    1619 <unroot+0x4d9>
lea    0x8(%rcx),%rsi
mov    %r10d,%edx
shl    $0x3,%rdx
mov    %rcx,%rdi
mov    %r9,%rbp
call   1050 <memmove@plt>
mov    %rbp,%r9
mov    0x8(%rsp),%r10
test   %r9,%r9
je     165c <unroot+0x51c>
mov    (%r9),%rdi
mov    %r10,%rbp
mov    %r9,%r12
call   1030 <free@plt>
test   %ebp,%ebp
jle    1643 <unroot+0x503>
lea    0x8(%r12),%rsi
mov    %ebp,%edx
shl    $0x3,%rdx
mov    %r12,%rdi
call   1050 <memmove@plt>
mov    $0x65,%edi
mov    $0x1,%esi
call   1060 <check_alloc@plt>
movslq %ebp,%rcx
mov    %rax,(%r12,%rcx,8)
mov    %rbp,%r10
mov    %r14d,%r8d
test   %r10d,%r10d
jle    1888 <unroot+0x748>
lea    0x1(%r10),%r12d
mov    %r8d,%r11d
mov    %r11d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x30(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r9d
and    $0x3,%r9d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rsp)
mov    %r11d,%r13d
and    $0x3,%r13d
mov    %r9,0x48(%rsp)
shl    $0x5,%r9
mov    $0x1,%r14d
jmp    16cd <unroot+0x58d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
cmp    %r12,%r14
je     1888 <unroot+0x748>
cmp    $0x3,%r10d
jl     16c0 <unroot+0x580>
mov    -0x8(%r15,%r14,8),%rdx
mov    (%r15,%r14,8),%rsi
cmp    $0x8,%r8d
jb     16f4 <unroot+0x5b4>
lea    (%rsi,%r11,4),%rax
cmp    %rax,%rdx
jae    175c <unroot+0x61c>
lea    (%rdx,%r11,4),%rax
cmp    %rax,%rsi
jae    175c <unroot+0x61c>
xor    %eax,%eax
mov    %rax,%rbp
not    %rbp
add    %r11,%rbp
test   %r13,%r13
je     1720 <unroot+0x5e0>
mov    %r13,%rcx
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rax,4),%edi
mov    %edi,(%rdx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    1710 <unroot+0x5d0>
cmp    $0x3,%rbp
jb     16c0 <unroot+0x580>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%rax,4),%ecx
mov    %ecx,(%rdx,%rax,4)
mov    0x4(%rsi,%rax,4),%ecx
mov    %ecx,0x4(%rdx,%rax,4)
mov    0x8(%rsi,%rax,4),%ecx
mov    %ecx,0x8(%rdx,%rax,4)
mov    0xc(%rsi,%rax,4),%ecx
mov    %ecx,0xc(%rdx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1730 <unroot+0x5f0>
jmp    16c0 <unroot+0x580>
cmpq   $0x18,0x28(%rsp)
jae    1768 <unroot+0x628>
xor    %eax,%eax
jmp    17cc <unroot+0x68c>
mov    0x40(%rsp),%r10
xor    %eax,%eax
nop
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movupd 0x60(%rsi,%rax,4),%xmm0
movupd 0x70(%rsi,%rax,4),%xmm1
movupd %xmm0,0x60(%rdx,%rax,4)
movupd %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1770 <unroot+0x630>
cmpq   $0x0,0x48(%rsp)
je     1810 <unroot+0x6d0>
lea    (%rdx,%rax,4),%rbp
add    $0x10,%rbp
lea    (%rsi,%rax,4),%rax
add    $0x10,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rax,%rcx,1),%xmm0
movupd (%rax,%rcx,1),%xmm1
movupd %xmm0,-0x10(%rbp,%rcx,1)
movupd %xmm1,0x0(%rbp,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r9
jne    17f0 <unroot+0x6b0>
mov    0x30(%rsp),%rcx
mov    %rcx,%rax
cmp    %r11,%rcx
mov    0x8(%rsp),%r10
je     16c0 <unroot+0x580>
jmp    16f6 <unroot+0x5b6>
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rdi
cmp    %rsi,%rax
je     15f1 <unroot+0x4b1>
test   %rdx,%rdx
je     184c <unroot+0x70c>
movsd  0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
test   %r8,%r8
je     185e <unroot+0x71e>
movsd  0x8(%r8,%rdi,8),%xmm0
movsd  %xmm0,(%r8,%rdi,8)
test   %rdx,%rdx
je     186f <unroot+0x72f>
movsd  0x10(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rdi,8)
lea    0x2(%rdi),%rsi
test   %r8,%r8
je     1830 <unroot+0x6f0>
movsd  0x10(%r8,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r8,%rdi,8)
jmp    1830 <unroot+0x6f0>
lea    0x1(%rbx),%ecx
xor    %eax,%eax
cmp    %r8d,%ecx
jge    1938 <unroot+0x7f8>
mov    %r8d,%r11d
movslq %ebx,%rax
lea    0x1(%rax),%rcx
mov    %r10d,%r9d
lea    -0x1(%r9),%r8
mov    %r9d,%edi
and    $0x3,%edi
and    $0xfffffffc,%r9d
jmp    18cd <unroot+0x78d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
add    $0x1,%rcx
cmp    %ecx,%r11d
je     1936 <unroot+0x7f6>
test   %r10d,%r10d
jle    18c0 <unroot+0x780>
xor    %ebp,%ebp
cmp    $0x3,%r8
jb     1914 <unroot+0x7d4>
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rbp,8),%rdx
mov    (%rdx,%rcx,4),%esi
mov    %esi,(%rdx,%rax,4)
mov    0x8(%r15,%rbp,8),%rdx
mov    (%rdx,%rcx,4),%esi
mov    %esi,(%rdx,%rax,4)
mov    0x10(%r15,%rbp,8),%rdx
mov    (%rdx,%rcx,4),%esi
mov    %esi,(%rdx,%rax,4)
mov    0x18(%r15,%rbp,8),%rdx
mov    (%rdx,%rcx,4),%esi
mov    %esi,(%rdx,%rax,4)
add    $0x4,%rbp
cmp    %rbp,%r9
jne    18e0 <unroot+0x7a0>
test   %rdi,%rdi
je     18c0 <unroot+0x780>
lea    (%r15,%rbp,8),%rbp
xor    %esi,%esi
nop
mov    0x0(%rbp,%rsi,8),%rbx
mov    (%rbx,%rcx,4),%edx
mov    %edx,(%rbx,%rax,4)
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1920 <unroot+0x7e0>
jmp    18c0 <unroot+0x780>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xffffffff,%ebx
mov    $0xffffffff,%eax
jmp    122a <unroot+0xea>
mov    0x20(%rsp),%rdx
test   %rdx,%rdx
je     1992 <unroot+0x852>
mov    %ebx,%eax
movsd  (%rdx,%rax,8),%xmm2
mov    $0xffffffff,%eax
mov    %r8d,%esi
mov    0x8(%rsp),%r10
mov    0x4(%rsp),%r14d
mov    0x38(%rsp),%r9
mov    0x50(%rsp),%rcx
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r11
jmp    122a <unroot+0xea>
mov    $0xffffffff,%eax
mov    0x8(%rsp),%r10
mov    0x4(%rsp),%r14d
mov    0x38(%rsp),%r9
mov    0x50(%rsp),%rcx
mov    0x18(%rsp),%r8
jmp    1a54 <unroot+0x914>
mov    0x50(%rsp),%rcx
test   %rcx,%rcx
je     1a36 <unroot+0x8f6>
mov    %ebx,%r12d
mov    0x20(%rsp),%rdx
movsd  (%rdx,%r12,8),%xmm2
mov    0x8(%rsp),%r10
test   %r10d,%r10d
mov    0x4(%rsp),%r14d
mov    0x38(%rsp),%r9
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r11
mov    $0xffffffff,%esi
jle    1a11 <unroot+0x8d1>
mov    0x28(%rsp),%ebp
mov    $0x1,%eax
mov    (%r15,%rax,8),%rdi
cmpl   $0x0,(%rdi,%r12,4)
je     122a <unroot+0xea>
add    $0x1,%rax
cmp    %rax,%rbp
jne    19f9 <unroot+0x8b9>
mov    $0xffffffff,%eax
jmp    122a <unroot+0xea>
mov    $0xffffffff,%ebx
mov    $0xffffffff,%eax
mov    0x4(%rsp),%r14d
mov    0x38(%rsp),%r9
mov    0x50(%rsp),%rcx
jmp    1a4a <unroot+0x90a>
mov    $0xffffffff,%eax
mov    0x8(%rsp),%r10
mov    0x4(%rsp),%r14d
mov    0x38(%rsp),%r9
mov    0x18(%rsp),%r8
mov    0x20(%rsp),%rdx
mov    0x10(%rsp),%r11
mov    $0xffffffff,%esi
jmp    122a <unroot+0xea>

LLVM IR (-O0):
@.str = [10 x i8] c"probleme\0A\00"
define i32 @unroot(i32** %0, i32 %1, double* %2, double* %3, double* %4, i8** %5, i8** %6, i8** %7, i32* %8, i32* %9, double* %10) {
%12 = alloca i32
%13 = alloca i32**
%14 = alloca i32
%15 = alloca double*
%16 = alloca double*
%17 = alloca double*
%18 = alloca i8**
%19 = alloca i8**
%20 = alloca i8**
%21 = alloca i32*
%22 = alloca i32*
%23 = alloca double*
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca double
store i32** %0, i32*** %13
store i32 %1, i32* %14
store double* %2, double** %15
store double* %3, double** %16
store double* %4, double** %17
store i8** %5, i8*** %18
store i8** %6, i8*** %19
store i8** %7, i8*** %20
store i32* %8, i32** %21
store i32* %9, i32** %22
store double* %10, double** %23
store i32 -1, i32* %28
store i32 -1, i32* %29
store i32 -1, i32* %30
store i32 0, i32* %25
br label %35
35: ; preds = %51, %11
%36 = load i32, i32* %25
%37 = load i32, i32* %14
%38 = sub nsw i32 %37, 2
%39 = icmp slt i32 %36, %38
br i1 %39, label %40, label %54
40: ; preds = %35
%41 = load i32**, i32*** %13
%42 = getelementptr inbounds i32*, i32** %41, i64 0
%43 = load i32*, i32** %42
%44 = load i32, i32* %25
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %43, i64 %45
%47 = load i32, i32* %46
%48 = icmp ne i32 %47, 0
br i1 %48, label %49, label %50
49: ; preds = %40
store i32 1, i32* %12
br label %509
50: ; preds = %40
br label %51
51: ; preds = %50
%52 = load i32, i32* %25
%53 = add nsw i32 %52, 1
store i32 %53, i32* %25
br label %35
54: ; preds = %35
store i32 0, i32* %26
br label %55
55: ; preds = %216, %54
%56 = load i32, i32* %26
%57 = load i32, i32* %14
%58 = sub nsw i32 %57, 3
%59 = icmp slt i32 %56, %58
br i1 %59, label %60, label %219
60: ; preds = %55
store i32 0, i32* %31
store i32 0, i32* %24
br label %61
61: ; preds = %78, %60
%62 = load i32, i32* %24
%63 = load i32, i32* %14
%64 = add nsw i32 %63, 1
%65 = icmp slt i32 %62, %64
br i1 %65, label %66, label %81
66: ; preds = %61
%67 = load i32**, i32*** %13
%68 = load i32, i32* %24
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i32*, i32** %67, i64 %69
%71 = load i32*, i32** %70
%72 = load i32, i32* %26
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %71, i64 %73
%75 = load i32, i32* %74
%76 = load i32, i32* %31
%77 = add nsw i32 %76, %75
store i32 %77, i32* %31
br label %78
78: ; preds = %66
%79 = load i32, i32* %24
%80 = add nsw i32 %79, 1
store i32 %80, i32* %24
br label %61
81: ; preds = %61
%82 = load i32, i32* %31
%83 = load i32, i32* %14
%84 = sub nsw i32 %83, 1
%85 = icmp eq i32 %82, %84
br i1 %85, label %86, label %120
86: ; preds = %81
%87 = load i32, i32* %26
store i32 %87, i32* %28
%88 = load double*, double** %16
%89 = icmp ne double* %88, null
br i1 %89, label %90, label %119
90: ; preds = %86
%91 = load double*, double** %15
%92 = load i32, i32* %26
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds double, double* %91, i64 %93
%95 = load double, double* %94
store double %95, double* %34
store i32 1, i32* %24
br label %96
96: ; preds = %115, %90
%97 = load i32, i32* %24
%98 = load i32, i32* %14
%99 = add nsw i32 %98, 1
%100 = icmp slt i32 %97, %99
br i1 %100, label %101, label %118
101: ; preds = %96
%102 = load i32**, i32*** %13
%103 = load i32, i32* %24
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i32*, i32** %102, i64 %104
%106 = load i32*, i32** %105
%107 = load i32, i32* %26
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %106, i64 %108
%110 = load i32, i32* %109
%111 = icmp eq i32 %110, 0
br i1 %111, label %112, label %114
112: ; preds = %101
%113 = load i32, i32* %24
store i32 %113, i32* %29
br label %118
114: ; preds = %101
br label %115
115: ; preds = %114
%116 = load i32, i32* %24
%117 = add nsw i32 %116, 1
store i32 %117, i32* %24
br label %96
118: ; preds = %112, %96
br label %119
119: ; preds = %118, %86
br label %219
120: ; preds = %81
%121 = load i32, i32* %26
%122 = add nsw i32 %121, 1
store i32 %122, i32* %27
br label %123
123: ; preds = %208, %120
%124 = load i32, i32* %27
%125 = load i32, i32* %14
%126 = sub nsw i32 %125, 2
%127 = icmp slt i32 %124, %126
br i1 %127, label %128, label %211
128: ; preds = %123
store i32 0, i32* %32
store i32 0, i32* %24
br label %129
129: ; preds = %146, %128
%130 = load i32, i32* %24
%131 = load i32, i32* %14
%132 = add nsw i32 %131, 1
%133 = icmp slt i32 %130, %132
br i1 %133, label %134, label %149
134: ; preds = %129
%135 = load i32**, i32*** %13
%136 = load i32, i32* %24
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds i32*, i32** %135, i64 %137
%139 = load i32*, i32** %138
%140 = load i32, i32* %27
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %139, i64 %141
%143 = load i32, i32* %142
%144 = load i32, i32* %32
%145 = add nsw i32 %144, %143
store i32 %145, i32* %32
br label %146
146: ; preds = %134
%147 = load i32, i32* %24
%148 = add nsw i32 %147, 1
store i32 %148, i32* %24
br label %129
149: ; preds = %129
%150 = load i32, i32* %31
%151 = load i32, i32* %14
%152 = load i32, i32* %32
%153 = sub nsw i32 %151, %152
%154 = icmp eq i32 %150, %153
br i1 %154, label %155, label %203
155: ; preds = %149
store i32 0, i32* %33
store i32 1, i32* %24
br label %156
156: ; preds = %184, %155
%157 = load i32, i32* %24
%158 = load i32, i32* %14
%159 = icmp slt i32 %157, %158
br i1 %159, label %160, label %187
160: ; preds = %156
%161 = load i32**, i32*** %13
%162 = load i32, i32* %24
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i32*, i32** %161, i64 %163
%165 = load i32*, i32** %164
%166 = load i32, i32* %26
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %165, i64 %167
%169 = load i32, i32* %168
%170 = load i32**, i32*** %13
%171 = load i32, i32* %24
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i32*, i32** %170, i64 %172
%174 = load i32*, i32** %173
%175 = load i32, i32* %27
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i32, i32* %174, i64 %176
%178 = load i32, i32* %177
%179 = sub nsw i32 %169, %178
%180 = call i32 @abs(i32 %179)
%181 = icmp ne i32 %180, 1
br i1 %181, label %182, label %183
182: ; preds = %160
store i32 1, i32* %33
br label %183
183: ; preds = %182, %160
br label %184
184: ; preds = %183
%185 = load i32, i32* %24
%186 = add nsw i32 %185, 1
store i32 %186, i32* %24
br label %156
187: ; preds = %156
%188 = load i32, i32* %33
%189 = icmp eq i32 %188, 0
br i1 %189, label %190, label %202
190: ; preds = %187
%191 = load i32, i32* %26
store i32 %191, i32* %28
%192 = load double*, double** %15
%193 = icmp ne double* %192, null
br i1 %193, label %194, label %201
194: ; preds = %190
%195 = load i32, i32* %27
store i32 %195, i32* %30
%196 = load double*, double** %15
%197 = load i32, i32* %26
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double, double* %196, i64 %198
%200 = load double, double* %199
store double %200, double* %34
br label %201
201: ; preds = %194, %190
br label %211
202: ; preds = %187
br label %203
203: ; preds = %202, %149
%204 = load i32, i32* %28
%205 = icmp ne i32 %204, -1
br i1 %205, label %206, label %207
206: ; preds = %203
br label %211
207: ; preds = %203
br label %208
208: ; preds = %207
%209 = load i32, i32* %27
%210 = add nsw i32 %209, 1
store i32 %210, i32* %27
br label %123
211: ; preds = %206, %201, %123
%212 = load i32, i32* %28
%213 = icmp ne i32 %212, -1
br i1 %213, label %214, label %215
214: ; preds = %211
br label %219
215: ; preds = %211
br label %216
216: ; preds = %215
%217 = load i32, i32* %26
%218 = add nsw i32 %217, 1
store i32 %218, i32* %26
br label %55
219: ; preds = %214, %119, %55
%220 = load i32*, i32** %21
%221 = icmp ne i32* %220, null
br i1 %221, label %222, label %315
222: ; preds = %219
store i32 0, i32* %27
store i32 0, i32* %26
store i32 1, i32* %24
br label %223
223: ; preds = %263, %222
%224 = load i32, i32* %24
%225 = load i32, i32* %14
%226 = icmp sle i32 %224, %225
br i1 %226, label %227, label %266
227: ; preds = %223
%228 = load i32**, i32*** %13
%229 = load i32, i32* %24
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i32*, i32** %228, i64 %230
%232 = load i32*, i32** %231
%233 = load i32, i32* %28
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i32, i32* %232, i64 %234
%236 = load i32, i32* %235
%237 = icmp eq i32 %236, 0
br i1 %237, label %238, label %250
238: ; preds = %227
%239 = load i8**, i8*** %18
%240 = load i32, i32* %24
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i8*, i8** %239, i64 %241
%243 = load i8*, i8** %242
%244 = load i8**, i8*** %19
%245 = load i32, i32* %26
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds i8*, i8** %244, i64 %246
store i8* %243, i8** %247
%248 = load i32, i32* %26
%249 = add nsw i32 %248, 1
store i32 %249, i32* %26
br label %262
250: ; preds = %227
%251 = load i8**, i8*** %18
%252 = load i32, i32* %24
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds i8*, i8** %251, i64 %253
%255 = load i8*, i8** %254
%256 = load i8**, i8*** %20
%257 = load i32, i32* %27
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i8*, i8** %256, i64 %258
store i8* %255, i8** %259
%260 = load i32, i32* %27
%261 = add nsw i32 %260, 1
store i32 %261, i32* %27
br label %262
262: ; preds = %250, %238
br label %263
263: ; preds = %262
%264 = load i32, i32* %24
%265 = add nsw i32 %264, 1
store i32 %265, i32* %24
br label %223
266: ; preds = %223
%267 = load i32, i32* %26
%268 = icmp slt i32 %267, 1
br i1 %268, label %272, label %269
269: ; preds = %266
%270 = load i32, i32* %27
%271 = icmp slt i32 %270, 1
br i1 %271, label %272, label %274
272: ; preds = %269, %266
%273 = call i32 @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0))
br label %274
274: ; preds = %272, %269
%275 = load i32, i32* %26
%276 = load i32*, i32** %21
store i32 %275, i32* %276
%277 = load i32, i32* %27
%278 = load i32*, i32** %22
store i32 %277, i32* %278
%279 = load i32, i32* %29
%280 = icmp ne i32 %279, -1
br i1 %280, label %281, label %296
281: ; preds = %274
%282 = load double*, double** %16
%283 = load i32, i32* %29
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds double, double* %282, i64 %284
%286 = load double, double* %285
%287 = load double*, double** %16
%288 = load i32, i32* %29
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %287, i64 %289
%291 = load double, double* %290
%292 = load double, double* %34
%293 = fadd double %291, %292
%294 = fdiv double %286, %293
%295 = load double*, double** %23
store double %294, double* %295
br label %296
296: ; preds = %281, %274
%297 = load i32, i32* %30
%298 = icmp ne i32 %297, -1
br i1 %298, label %299, label %314
299: ; preds = %296
%300 = load double*, double** %15
%301 = load i32, i32* %30
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds double, double* %300, i64 %302
%304 = load double, double* %303
%305 = load double*, double** %15
%306 = load i32, i32* %30
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds double, double* %305, i64 %307
%309 = load double, double* %308
%310 = load double, double* %34
%311 = fadd double %309, %310
%312 = fdiv double %304, %311
%313 = load double*, double** %23
store double %312, double* %313
br label %314
314: ; preds = %299, %296
br label %315
315: ; preds = %314, %219
%316 = load i32, i32* %29
%317 = icmp ne i32 %316, -1
br i1 %317, label %318, label %326
318: ; preds = %315
%319 = load double, double* %34
%320 = load double*, double** %16
%321 = load i32, i32* %29
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds double, double* %320, i64 %322
%324 = load double, double* %323
%325 = fadd double %324, %319
store double %325, double* %323
br label %326
326: ; preds = %318, %315
%327 = load i32, i32* %30
%328 = icmp ne i32 %327, -1
br i1 %328, label %329, label %337
329: ; preds = %326
%330 = load double, double* %34
%331 = load double*, double** %15
%332 = load i32, i32* %30
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %331, i64 %333
%335 = load double, double* %334
%336 = fadd double %335, %330
store double %336, double* %334
br label %337
337: ; preds = %329, %326
%338 = load i32, i32* %28
store i32 %338, i32* %24
br label %339
339: ; preds = %373, %337
%340 = load i32, i32* %24
%341 = load i32, i32* %14
%342 = sub nsw i32 %341, 3
%343 = icmp slt i32 %340, %342
br i1 %343, label %344, label %376
344: ; preds = %339
%345 = load double*, double** %15
%346 = icmp ne double* %345, null
br i1 %346, label %347, label %358
347: ; preds = %344
%348 = load double*, double** %15
%349 = load i32, i32* %24
%350 = add nsw i32 %349, 1
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %348, i64 %351
%353 = load double, double* %352
%354 = load double*, double** %15
%355 = load i32, i32* %24
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds double, double* %354, i64 %356
store double %353, double* %357
br label %358
358: ; preds = %347, %344
%359 = load double*, double** %17
%360 = icmp ne double* %359, null
br i1 %360, label %361, label %372
361: ; preds = %358
%362 = load double*, double** %17
%363 = load i32, i32* %24
%364 = add nsw i32 %363, 1
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds double, double* %362, i64 %365
%367 = load double, double* %366
%368 = load double*, double** %17
%369 = load i32, i32* %24
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds double, double* %368, i64 %370
store double %367, double* %371
br label %372
372: ; preds = %361, %358
br label %373
373: ; preds = %372
%374 = load i32, i32* %24
%375 = add nsw i32 %374, 1
store i32 %375, i32* %24
br label %339
376: ; preds = %339
%377 = load double*, double** %16
%378 = icmp ne double* %377, null
br i1 %378, label %379, label %399
379: ; preds = %376
store i32 0, i32* %24
br label %380
380: ; preds = %395, %379
%381 = load i32, i32* %24
%382 = load i32, i32* %14
%383 = icmp slt i32 %381, %382
br i1 %383, label %384, label %398
384: ; preds = %380
%385 = load double*, double** %16
%386 = load i32, i32* %24
%387 = add nsw i32 %386, 1
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds double, double* %385, i64 %388
%390 = load double, double* %389
%391 = load double*, double** %16
%392 = load i32, i32* %24
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds double, double* %391, i64 %393
store double %390, double* %394
br label %395
395: ; preds = %384
%396 = load i32, i32* %24
%397 = add nsw i32 %396, 1
store i32 %397, i32* %24
br label %380
398: ; preds = %380
br label %399
399: ; preds = %398, %376
%400 = load i8**, i8*** %18
%401 = icmp ne i8** %400, null
br i1 %401, label %402, label %431
402: ; preds = %399
%403 = load i8**, i8*** %18
%404 = getelementptr inbounds i8*, i8** %403, i64 0
%405 = load i8*, i8** %404
%406 = call i32 @free(i8* %405)
store i32 0, i32* %24
br label %407
407: ; preds = %422, %402
%408 = load i32, i32* %24
%409 = load i32, i32* %14
%410 = icmp slt i32 %408, %409
br i1 %410, label %411, label %425
411: ; preds = %407
%412 = load i8**, i8*** %18
%413 = load i32, i32* %24
%414 = add nsw i32 %413, 1
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds i8*, i8** %412, i64 %415
%417 = load i8*, i8** %416
%418 = load i8**, i8*** %18
%419 = load i32, i32* %24
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds i8*, i8** %418, i64 %420
store i8* %417, i8** %421
br label %422
422: ; preds = %411
%423 = load i32, i32* %24
%424 = add nsw i32 %423, 1
store i32 %424, i32* %24
br label %407
425: ; preds = %407
%426 = call i8* @check_alloc(i32 101, i32 1)
%427 = load i8**, i8*** %18
%428 = load i32, i32* %14
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds i8*, i8** %427, i64 %429
store i8* %426, i8** %430
br label %431
431: ; preds = %425, %399
store i32 1, i32* %24
br label %432
432: ; preds = %466, %431
%433 = load i32, i32* %24
%434 = load i32, i32* %14
%435 = add nsw i32 %434, 1
%436 = icmp slt i32 %433, %435
br i1 %436, label %437, label %469
437: ; preds = %432
store i32 0, i32* %25
br label %438
438: ; preds = %462, %437
%439 = load i32, i32* %25
%440 = load i32, i32* %14
%441 = sub nsw i32 %440, 2
%442 = icmp slt i32 %439, %441
br i1 %442, label %443, label %465
443: ; preds = %438
%444 = load i32**, i32*** %13
%445 = load i32, i32* %24
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds i32*, i32** %444, i64 %446
%448 = load i32*, i32** %447
%449 = load i32, i32* %25
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds i32, i32* %448, i64 %450
%452 = load i32, i32* %451
%453 = load i32**, i32*** %13
%454 = load i32, i32* %24
%455 = sub nsw i32 %454, 1
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds i32*, i32** %453, i64 %456
%458 = load i32*, i32** %457
%459 = load i32, i32* %25
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds i32, i32* %458, i64 %460
store i32 %452, i32* %461
br label %462
462: ; preds = %443
%463 = load i32, i32* %25
%464 = add nsw i32 %463, 1
store i32 %464, i32* %25
br label %438
465: ; preds = %438
br label %466
466: ; preds = %465
%467 = load i32, i32* %24
%468 = add nsw i32 %467, 1
store i32 %468, i32* %24
br label %432
469: ; preds = %432
%470 = load i32, i32* %28
%471 = add nsw i32 %470, 1
store i32 %471, i32* %25
br label %472
472: ; preds = %505, %469
%473 = load i32, i32* %25
%474 = load i32, i32* %14
%475 = sub nsw i32 %474, 2
%476 = icmp slt i32 %473, %475
br i1 %476, label %477, label %508
477: ; preds = %472
store i32 0, i32* %24
br label %478
478: ; preds = %501, %477
%479 = load i32, i32* %24
%480 = load i32, i32* %14
%481 = icmp slt i32 %479, %480
br i1 %481, label %482, label %504
482: ; preds = %478
%483 = load i32**, i32*** %13
%484 = load i32, i32* %24
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i32*, i32** %483, i64 %485
%487 = load i32*, i32** %486
%488 = load i32, i32* %25
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds i32, i32* %487, i64 %489
%491 = load i32, i32* %490
%492 = load i32**, i32*** %13
%493 = load i32, i32* %24
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds i32*, i32** %492, i64 %494
%496 = load i32*, i32** %495
%497 = load i32, i32* %25
%498 = sub nsw i32 %497, 1
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds i32, i32* %496, i64 %499
store i32 %491, i32* %500
br label %501
501: ; preds = %482
%502 = load i32, i32* %24
%503 = add nsw i32 %502, 1
store i32 %503, i32* %24
br label %478
504: ; preds = %478
br label %505
505: ; preds = %504
%506 = load i32, i32* %25
%507 = add nsw i32 %506, 1
store i32 %507, i32* %25
br label %472
508: ; preds = %472
store i32 0, i32* %12
br label %509
509: ; preds = %508, %49
%510 = load i32, i32* %12
ret i32 %510
}

LLVM IR (-O2):
@str = [9 x i8] c"probleme\00"
define i32 @unroot(i32** nocapture %0, i32 %1, double* %2, double* %3, double* %4, i8** %5, i8** nocapture writeonly %6, i8** nocapture writeonly %7, i32* writeonly %8, i32* nocapture writeonly %9, double* nocapture writeonly %10) {
%12 = bitcast double* %3 to i8*
%13 = bitcast i8** %5 to i8*
%14 = add i32 %1, -2
%15 = icmp sgt i32 %1, 2
br i1 %15, label %18, label %16
16: ; preds = %11
%17 = add i32 %1, -3
br label %244
18: ; preds = %11
%19 = load i32*, i32** %0
%20 = zext i32 %14 to i64
br label %48
21: ; preds = %48
%22 = icmp eq i64 %53, %20
br i1 %22, label %23, label %48
23: ; preds = %21
%24 = add i32 %1, -3
%25 = icmp sgt i32 %1, 3
br i1 %25, label %26, label %244
26: ; preds = %23
%27 = add nsw i32 %1, -1
%28 = add nuw i32 %1, 1
%29 = zext i32 %14 to i64
%30 = zext i32 %24 to i64
%31 = zext i32 %28 to i64
%32 = zext i32 %14 to i64
%33 = zext i32 %1 to i64
%34 = add nsw i64 %31, -1
%35 = add nsw i64 %33, -1
%36 = and i64 %31, 3
%37 = icmp ult i64 %34, 3
%38 = and i64 %31, 4294967292
%39 = icmp eq i64 %36, 0
%40 = and i64 %31, 3
%41 = icmp ult i64 %34, 3
%42 = and i64 %31, 4294967292
%43 = icmp eq i64 %40, 0
%44 = and i64 %35, 1
%45 = icmp eq i32 %1, 2
%46 = and i64 %35, -2
%47 = icmp eq i64 %44, 0
br label %57
48: ; preds = %18, %21
%49 = phi i64 [ 0, %18 ], [ %53, %21 ]
%50 = getelementptr inbounds i32, i32* %19, i64 %49
%51 = load i32, i32* %50
%52 = icmp eq i32 %51, 0
%53 = add nuw nsw i64 %49, 1
br i1 %52, label %21, label %601
54: ; preds = %239, %129
%55 = add nuw nsw i64 %59, 1
%56 = icmp eq i64 %130, %30
br i1 %56, label %244, label %57
57: ; preds = %54, %26
%58 = phi i64 [ 0, %26 ], [ %130, %54 ]
%59 = phi i64 [ 1, %26 ], [ %55, %54 ]
br i1 %37, label %90, label %60
60: ; preds = %57, %60
%61 = phi i64 [ %87, %60 ], [ 0, %57 ]
%62 = phi i32 [ %86, %60 ], [ 0, %57 ]
%63 = phi i64 [ %88, %60 ], [ 0, %57 ]
%64 = getelementptr inbounds i32*, i32** %0, i64 %61
%65 = load i32*, i32** %64
%66 = getelementptr inbounds i32, i32* %65, i64 %58
%67 = load i32, i32* %66
%68 = add nsw i32 %67, %62
%69 = or i64 %61, 1
%70 = getelementptr inbounds i32*, i32** %0, i64 %69
%71 = load i32*, i32** %70
%72 = getelementptr inbounds i32, i32* %71, i64 %58
%73 = load i32, i32* %72
%74 = add nsw i32 %73, %68
%75 = or i64 %61, 2
%76 = getelementptr inbounds i32*, i32** %0, i64 %75
%77 = load i32*, i32** %76
%78 = getelementptr inbounds i32, i32* %77, i64 %58
%79 = load i32, i32* %78
%80 = add nsw i32 %79, %74
%81 = or i64 %61, 3
%82 = getelementptr inbounds i32*, i32** %0, i64 %81
%83 = load i32*, i32** %82
%84 = getelementptr inbounds i32, i32* %83, i64 %58
%85 = load i32, i32* %84
%86 = add nsw i32 %85, %80
%87 = add nuw nsw i64 %61, 4
%88 = add i64 %63, 4
%89 = icmp eq i64 %88, %38
br i1 %89, label %90, label %60
90: ; preds = %60, %57
%91 = phi i32 [ undef, %57 ], [ %86, %60 ]
%92 = phi i64 [ 0, %57 ], [ %87, %60 ]
%93 = phi i32 [ 0, %57 ], [ %86, %60 ]
br i1 %39, label %106, label %94
94: ; preds = %90, %94
%95 = phi i64 [ %103, %94 ], [ %92, %90 ]
%96 = phi i32 [ %102, %94 ], [ %93, %90 ]
%97 = phi i64 [ %104, %94 ], [ 0, %90 ]
%98 = getelementptr inbounds i32*, i32** %0, i64 %95
%99 = load i32*, i32** %98
%100 = getelementptr inbounds i32, i32* %99, i64 %58
%101 = load i32, i32* %100
%102 = add nsw i32 %101, %96
%103 = add nuw nsw i64 %95, 1
%104 = add i64 %97, 1
%105 = icmp eq i64 %104, %36
br i1 %105, label %106, label %94
106: ; preds = %94, %90
%107 = phi i32 [ %91, %90 ], [ %102, %94 ]
%108 = icmp eq i32 %107, %27
br i1 %108, label %109, label %129
109: ; preds = %106
%110 = trunc i64 %58 to i32
%111 = icmp eq double* %3, null
br i1 %111, label %244, label %112
112: ; preds = %109
%113 = and i64 %58, 4294967295
%114 = getelementptr inbounds double, double* %2, i64 %113
%115 = load double, double* %114
%116 = icmp slt i32 %1, 1
br i1 %116, label %244, label %117
117: ; preds = %112
%118 = zext i32 %28 to i64
br label %119
119: ; preds = %117, %126
%120 = phi i64 [ 1, %117 ], [ %127, %126 ]
%121 = getelementptr inbounds i32*, i32** %0, i64 %120
%122 = load i32*, i32** %121
%123 = getelementptr inbounds i32, i32* %122, i64 %113
%124 = load i32, i32* %123
%125 = icmp eq i32 %124, 0
br i1 %125, label %242, label %126
126: ; preds = %119
%127 = add nuw nsw i64 %120, 1
%128 = icmp eq i64 %127, %118
br i1 %128, label %244, label %119
129: ; preds = %106
%130 = add nuw nsw i64 %58, 1
%131 = icmp ult i64 %130, %29
br i1 %131, label %132, label %54
132: ; preds = %129, %239
%133 = phi i64 [ %240, %239 ], [ %59, %129 ]
br i1 %41, label %164, label %134
134: ; preds = %132, %134
%135 = phi i64 [ %161, %134 ], [ 0, %132 ]
%136 = phi i32 [ %160, %134 ], [ 0, %132 ]
%137 = phi i64 [ %162, %134 ], [ 0, %132 ]
%138 = getelementptr inbounds i32*, i32** %0, i64 %135
%139 = load i32*, i32** %138
%140 = getelementptr inbounds i32, i32* %139, i64 %133
%141 = load i32, i32* %140
%142 = add nsw i32 %141, %136
%143 = or i64 %135, 1
%144 = getelementptr inbounds i32*, i32** %0, i64 %143
%145 = load i32*, i32** %144
%146 = getelementptr inbounds i32, i32* %145, i64 %133
%147 = load i32, i32* %146
%148 = add nsw i32 %147, %142
%149 = or i64 %135, 2
%150 = getelementptr inbounds i32*, i32** %0, i64 %149
%151 = load i32*, i32** %150
%152 = getelementptr inbounds i32, i32* %151, i64 %133
%153 = load i32, i32* %152
%154 = add nsw i32 %153, %148
%155 = or i64 %135, 3
%156 = getelementptr inbounds i32*, i32** %0, i64 %155
%157 = load i32*, i32** %156
%158 = getelementptr inbounds i32, i32* %157, i64 %133
%159 = load i32, i32* %158
%160 = add nsw i32 %159, %154
%161 = add nuw nsw i64 %135, 4
%162 = add i64 %137, 4
%163 = icmp eq i64 %162, %42
br i1 %163, label %164, label %134
164: ; preds = %134, %132
%165 = phi i32 [ undef, %132 ], [ %160, %134 ]
%166 = phi i64 [ 0, %132 ], [ %161, %134 ]
%167 = phi i32 [ 0, %132 ], [ %160, %134 ]
br i1 %43, label %180, label %168
168: ; preds = %164, %168
%169 = phi i64 [ %177, %168 ], [ %166, %164 ]
%170 = phi i32 [ %176, %168 ], [ %167, %164 ]
%171 = phi i64 [ %178, %168 ], [ 0, %164 ]
%172 = getelementptr inbounds i32*, i32** %0, i64 %169
%173 = load i32*, i32** %172
%174 = getelementptr inbounds i32, i32* %173, i64 %133
%175 = load i32, i32* %174
%176 = add nsw i32 %175, %170
%177 = add nuw nsw i64 %169, 1
%178 = add i64 %171, 1
%179 = icmp eq i64 %178, %40
br i1 %179, label %180, label %168
180: ; preds = %168, %164
%181 = phi i32 [ %165, %164 ], [ %176, %168 ]
%182 = sub nsw i32 %1, %181
%183 = icmp eq i32 %107, %182
br i1 %183, label %184, label %239
184: ; preds = %180
br i1 %45, label %213, label %185
185: ; preds = %184, %185
%186 = phi i64 [ %210, %185 ], [ 1, %184 ]
%187 = phi i32 [ %209, %185 ], [ 0, %184 ]
%188 = phi i64 [ %211, %185 ], [ 0, %184 ]
%189 = getelementptr inbounds i32*, i32** %0, i64 %186
%190 = load i32*, i32** %189
%191 = getelementptr inbounds i32, i32* %190, i64 %58
%192 = load i32, i32* %191
%193 = getelementptr inbounds i32, i32* %190, i64 %133
%194 = load i32, i32* %193
%195 = sub nsw i32 %192, %194
%196 = tail call i32 @llvm.abs.i32(i32 %195, i1 true)
%197 = icmp eq i32 %196, 1
%198 = add nuw nsw i64 %186, 1
%199 = getelementptr inbounds i32*, i32** %0, i64 %198
%200 = load i32*, i32** %199
%201 = getelementptr inbounds i32, i32* %200, i64 %58
%202 = load i32, i32* %201
%203 = getelementptr inbounds i32, i32* %200, i64 %133
%204 = load i32, i32* %203
%205 = sub nsw i32 %202, %204
%206 = tail call i32 @llvm.abs.i32(i32 %205, i1 true)
%207 = icmp eq i32 %206, 1
%208 = select i1 %207, i1 %197, i1 false
%209 = select i1 %208, i32 %187, i32 1
%210 = add nuw nsw i64 %186, 2
%211 = add nuw nsw i64 %188, 2
%212 = icmp eq i64 %211, %46
br i1 %212, label %213, label %185
213: ; preds = %185, %184
%214 = phi i32 [ undef, %184 ], [ %209, %185 ]
%215 = phi i64 [ 1, %184 ], [ %210, %185 ]
%216 = phi i32 [ 0, %184 ], [ %209, %185 ]
br i1 %47, label %228, label %217
217: ; preds = %213
%218 = getelementptr inbounds i32*, i32** %0, i64 %215
%219 = load i32*, i32** %218
%220 = getelementptr inbounds i32, i32* %219, i64 %58
%221 = load i32, i32* %220
%222 = getelementptr inbounds i32, i32* %219, i64 %133
%223 = load i32, i32* %222
%224 = sub nsw i32 %221, %223
%225 = tail call i32 @llvm.abs.i32(i32 %224, i1 true)
%226 = icmp eq i32 %225, 1
%227 = select i1 %226, i32 %216, i32 1
br label %228
228: ; preds = %213, %217
%229 = phi i32 [ %214, %213 ], [ %227, %217 ]
%230 = icmp eq i32 %229, 0
br i1 %230, label %231, label %239
231: ; preds = %228
%232 = trunc i64 %58 to i32
%233 = icmp eq double* %2, null
br i1 %233, label %244, label %234
234: ; preds = %231
%235 = trunc i64 %133 to i32
%236 = and i64 %58, 4294967295
%237 = getelementptr inbounds double, double* %2, i64 %236
%238 = load double, double* %237
br label %244
239: ; preds = %180, %228
%240 = add nuw nsw i64 %133, 1
%241 = icmp eq i64 %240, %32
br i1 %241, label %54, label %132
242: ; preds = %119
%243 = trunc i64 %120 to i32
br label %244
244: ; preds = %54, %126, %242, %16, %23, %112, %231, %234, %109
%245 = phi i32 [ %24, %109 ], [ %24, %234 ], [ %24, %231 ], [ %24, %112 ], [ %24, %23 ], [ %17, %16 ], [ %24, %242 ], [ %24, %126 ], [ %24, %54 ]
%246 = phi i32 [ %110, %109 ], [ %232, %234 ], [ %232, %231 ], [ %110, %112 ], [ -1, %23 ], [ -1, %16 ], [ %110, %242 ], [ %110, %126 ], [ -1, %54 ]
%247 = phi i32 [ -1, %109 ], [ -1, %234 ], [ -1, %231 ], [ -1, %112 ], [ -1, %23 ], [ -1, %16 ], [ %243, %242 ], [ -1, %126 ], [ -1, %54 ]
%248 = phi i32 [ -1, %109 ], [ %235, %234 ], [ -1, %231 ], [ -1, %112 ], [ -1, %23 ], [ -1, %16 ], [ -1, %242 ], [ -1, %126 ], [ -1, %54 ]
%249 = phi double [ undef, %109 ], [ %238, %234 ], [ undef, %231 ], [ %115, %112 ], [ undef, %23 ], [ undef, %16 ], [ %115, %242 ], [ %115, %126 ], [ undef, %54 ]
%250 = icmp eq i32* %8, null
br i1 %250, label %307, label %251
251: ; preds = %244
%252 = icmp slt i32 %1, 1
br i1 %252, label %285, label %253
253: ; preds = %251
%254 = sext i32 %246 to i64
%255 = add nuw i32 %1, 1
%256 = zext i32 %255 to i64
br label %257
257: ; preds = %253, %276
%258 = phi i64 [ 1, %253 ], [ %279, %276 ]
%259 = phi i32 [ 0, %253 ], [ %278, %276 ]
%260 = phi i32 [ 0, %253 ], [ %277, %276 ]
%261 = getelementptr inbounds i32*, i32** %0, i64 %258
%262 = load i32*, i32** %261
%263 = getelementptr inbounds i32, i32* %262, i64 %254
%264 = load i32, i32* %263
%265 = icmp eq i32 %264, 0
%266 = getelementptr inbounds i8*, i8** %5, i64 %258
%267 = load i8*, i8** %266
br i1 %265, label %268, label %272
268: ; preds = %257
%269 = sext i32 %260 to i64
%270 = getelementptr inbounds i8*, i8** %6, i64 %269
store i8* %267, i8** %270
%271 = add nsw i32 %260, 1
br label %276
272: ; preds = %257
%273 = sext i32 %259 to i64
%274 = getelementptr inbounds i8*, i8** %7, i64 %273
store i8* %267, i8** %274
%275 = add nsw i32 %259, 1
br label %276
276: ; preds = %268, %272
%277 = phi i32 [ %271, %268 ], [ %260, %272 ]
%278 = phi i32 [ %259, %268 ], [ %275, %272 ]
%279 = add nuw nsw i64 %258, 1
%280 = icmp eq i64 %279, %256
br i1 %280, label %281, label %257
281: ; preds = %276
%282 = icmp slt i32 %277, 1
%283 = icmp slt i32 %278, 1
%284 = select i1 %282, i1 true, i1 %283
br i1 %284, label %285, label %289
285: ; preds = %251, %281
%286 = phi i32 [ %278, %281 ], [ 0, %251 ]
%287 = phi i32 [ %277, %281 ], [ 0, %251 ]
%288 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str, i64 0, i64 0))
br label %289
289: ; preds = %281, %285
%290 = phi i32 [ %278, %281 ], [ %286, %285 ]
%291 = phi i32 [ %277, %281 ], [ %287, %285 ]
store i32 %291, i32* %8
store i32 %290, i32* %9
%292 = icmp eq i32 %247, -1
br i1 %292, label %299, label %293
293: ; preds = %289
%294 = sext i32 %247 to i64
%295 = getelementptr inbounds double, double* %3, i64 %294
%296 = load double, double* %295
%297 = fadd double %249, %296
%298 = fdiv double %296, %297
store double %298, double* %10
br label %299
299: ; preds = %293, %289
%300 = icmp eq i32 %248, -1
br i1 %300, label %307, label %301
301: ; preds = %299
%302 = sext i32 %248 to i64
%303 = getelementptr inbounds double, double* %2, i64 %302
%304 = load double, double* %303
%305 = fadd double %249, %304
%306 = fdiv double %304, %305
store double %306, double* %10
br label %307
307: ; preds = %299, %301, %244
%308 = icmp eq i32 %247, -1
br i1 %308, label %314, label %309
309: ; preds = %307
%310 = sext i32 %247 to i64
%311 = getelementptr inbounds double, double* %3, i64 %310
%312 = load double, double* %311
%313 = fadd double %249, %312
store double %313, double* %311
br label %314
314: ; preds = %309, %307
%315 = icmp eq i32 %248, -1
br i1 %315, label %321, label %316
316: ; preds = %314
%317 = sext i32 %248 to i64
%318 = getelementptr inbounds double, double* %2, i64 %317
%319 = load double, double* %318
%320 = fadd double %249, %319
store double %320, double* %318
br label %321
321: ; preds = %316, %314
%322 = icmp slt i32 %246, %245
br i1 %322, label %323, label %375
323: ; preds = %321
%324 = icmp eq double* %2, null
%325 = icmp eq double* %4, null
%326 = sext i32 %246 to i64
%327 = sext i32 %245 to i64
%328 = sub nsw i64 %327, %326
%329 = xor i64 %326, -1
%330 = and i64 %328, 1
%331 = icmp eq i64 %330, 0
br i1 %331, label %344, label %332
332: ; preds = %323
br i1 %324, label %338, label %333
333: ; preds = %332
%334 = add nsw i64 %326, 1
%335 = getelementptr inbounds double, double* %2, i64 %334
%336 = load double, double* %335
%337 = getelementptr inbounds double, double* %2, i64 %326
store double %336, double* %337
br label %338
338: ; preds = %333, %332
%339 = add nsw i64 %326, 1
br i1 %325, label %344, label %340
340: ; preds = %338
%341 = getelementptr inbounds double, double* %4, i64 %339
%342 = load double, double* %341
%343 = getelementptr inbounds double, double* %4, i64 %326
store double %342, double* %343
br label %344
344: ; preds = %338, %340, %323
%345 = phi i64 [ %326, %323 ], [ %339, %340 ], [ %339, %338 ]
%346 = sub nsw i64 0, %327
%347 = icmp eq i64 %329, %346
br i1 %347, label %375, label %348
348: ; preds = %344, %373
%349 = phi i64 [ %368, %373 ], [ %345, %344 ]
br i1 %324, label %355, label %350
350: ; preds = %348
%351 = add nsw i64 %349, 1
%352 = getelementptr inbounds double, double* %2, i64 %351
%353 = load double, double* %352
%354 = getelementptr inbounds double, double* %2, i64 %349
store double %353, double* %354
br label %355
355: ; preds = %350, %348
%356 = add nsw i64 %349, 1
br i1 %325, label %361, label %357
357: ; preds = %355
%358 = getelementptr inbounds double, double* %4, i64 %356
%359 = load double, double* %358
%360 = getelementptr inbounds double, double* %4, i64 %349
store double %359, double* %360
br label %361
361: ; preds = %355, %357
br i1 %324, label %367, label %362
362: ; preds = %361
%363 = add nsw i64 %349, 2
%364 = getelementptr inbounds double, double* %2, i64 %363
%365 = load double, double* %364
%366 = getelementptr inbounds double, double* %2, i64 %356
store double %365, double* %366
br label %367
367: ; preds = %362, %361
%368 = add nsw i64 %349, 2
br i1 %325, label %373, label %369
369: ; preds = %367
%370 = getelementptr inbounds double, double* %4, i64 %368
%371 = load double, double* %370
%372 = getelementptr inbounds double, double* %4, i64 %356
store double %371, double* %372
br label %373
373: ; preds = %369, %367
%374 = icmp eq i64 %368, %327
br i1 %374, label %375, label %348
375: ; preds = %344, %373, %321
%376 = icmp ne double* %3, null
%377 = icmp sgt i32 %1, 0
%378 = and i1 %376, %377
br i1 %378, label %379, label %384
379: ; preds = %375
%380 = getelementptr double, double* %3, i64 1
%381 = bitcast double* %380 to i8*
%382 = zext i32 %1 to i64
%383 = shl nuw nsw i64 %382, 3
br label %384
384: ; preds = %379, %375
%385 = icmp eq i8** %5, null
br i1 %385, label %398, label %386
386: ; preds = %384
%387 = load i8*, i8** %5
%388 = tail call i32 @free(i8* %387)
br i1 %377, label %389, label %394
389: ; preds = %386
%390 = getelementptr i8*, i8** %5, i64 1
%391 = bitcast i8** %390 to i8*
%392 = zext i32 %1 to i64
%393 = shl nuw nsw i64 %392, 3
br label %394
394: ; preds = %389, %386
%395 = tail call i8* @check_alloc(i32 101, i32 1)
%396 = sext i32 %1 to i64
%397 = getelementptr inbounds i8*, i8** %5, i64 %396
store i8* %395, i8** %397
br label %398
398: ; preds = %394, %384
%399 = icmp slt i32 %1, 1
br i1 %399, label %516, label %400
400: ; preds = %398
%401 = add nuw i32 %1, 1
%402 = zext i32 %401 to i64
%403 = zext i32 %14 to i64
%404 = and i64 %403, 4294967288
%405 = add nsw i64 %404, -8
%406 = lshr exact i64 %405, 3
%407 = add nuw nsw i64 %406, 1
%408 = icmp ult i32 %14, 8
%409 = and i64 %403, 4294967288
%410 = and i64 %407, 3
%411 = icmp ult i64 %405, 24
%412 = and i64 %407, 4611686018427387900
%413 = icmp eq i64 %410, 0
%414 = icmp eq i64 %409, %403
%415 = and i64 %403, 3
%416 = icmp eq i64 %415, 0
br label %417
417: ; preds = %400, %547
%418 = phi i64 [ 1, %400 ], [ %548, %547 ]
br i1 %15, label %419, label %547
419: ; preds = %417
%420 = getelementptr inbounds i32*, i32** %0, i64 %418
%421 = load i32*, i32** %420
%422 = add nsw i64 %418, -1
%423 = getelementptr inbounds i32*, i32** %0, i64 %422
%424 = load i32*, i32** %423
br i1 %408, label %500, label %425
425: ; preds = %419
%426 = getelementptr i32, i32* %424, i64 %403
%427 = getelementptr i32, i32* %421, i64 %403
%428 = icmp ult i32* %424, %427
%429 = icmp ult i32* %421, %426
%430 = and i1 %428, %429
br i1 %430, label %500, label %431
431: ; preds = %425
br i1 %411, label %481, label %432
432: ; preds = %431, %432
%433 = phi i64 [ %478, %432 ], [ 0, %431 ]
%434 = phi i64 [ %479, %432 ], [ 0, %431 ]
%435 = getelementptr inbounds i32, i32* %421, i64 %433
%436 = bitcast i32* %435 to <4 x i32>*
%437 = load <4 x i32>, <4 x i32>* %436
%438 = getelementptr inbounds i32, i32* %435, i64 4
%439 = bitcast i32* %438 to <4 x i32>*
%440 = load <4 x i32>, <4 x i32>* %439
%441 = getelementptr inbounds i32, i32* %424, i64 %433
%442 = bitcast i32* %441 to <4 x i32>*
store <4 x i32> %437, <4 x i32>* %442
%443 = getelementptr inbounds i32, i32* %441, i64 4
%444 = bitcast i32* %443 to <4 x i32>*
store <4 x i32> %440, <4 x i32>* %444
%445 = or i64 %433, 8
%446 = getelementptr inbounds i32, i32* %421, i64 %445
%447 = bitcast i32* %446 to <4 x i32>*
%448 = load <4 x i32>, <4 x i32>* %447
%449 = getelementptr inbounds i32, i32* %446, i64 4
%450 = bitcast i32* %449 to <4 x i32>*
%451 = load <4 x i32>, <4 x i32>* %450
%452 = getelementptr inbounds i32, i32* %424, i64 %445
%453 = bitcast i32* %452 to <4 x i32>*
store <4 x i32> %448, <4 x i32>* %453
%454 = getelementptr inbounds i32, i32* %452, i64 4
%455 = bitcast i32* %454 to <4 x i32>*
store <4 x i32> %451, <4 x i32>* %455
%456 = or i64 %433, 16
%457 = getelementptr inbounds i32, i32* %421, i64 %456
%458 = bitcast i32* %457 to <4 x i32>*
%459 = load <4 x i32>, <4 x i32>* %458
%460 = getelementptr inbounds i32, i32* %457, i64 4
%461 = bitcast i32* %460 to <4 x i32>*
%462 = load <4 x i32>, <4 x i32>* %461
%463 = getelementptr inbounds i32, i32* %424, i64 %456
%464 = bitcast i32* %463 to <4 x i32>*
store <4 x i32> %459, <4 x i32>* %464
%465 = getelementptr inbounds i32, i32* %463, i64 4
%466 = bitcast i32* %465 to <4 x i32>*
store <4 x i32> %462, <4 x i32>* %466
%467 = or i64 %433, 24
%468 = getelementptr inbounds i32, i32* %421, i64 %467
%469 = bitcast i32* %468 to <4 x i32>*
%470 = load <4 x i32>, <4 x i32>* %469
%471 = getelementptr inbounds i32, i32* %468, i64 4
%472 = bitcast i32* %471 to <4 x i32>*
%473 = load <4 x i32>, <4 x i32>* %472
%474 = getelementptr inbounds i32, i32* %424, i64 %467
%475 = bitcast i32* %474 to <4 x i32>*
store <4 x i32> %470, <4 x i32>* %475
%476 = getelementptr inbounds i32, i32* %474, i64 4
%477 = bitcast i32* %476 to <4 x i32>*
store <4 x i32> %473, <4 x i32>* %477
%478 = add nuw i64 %433, 32
%479 = add i64 %434, 4
%480 = icmp eq i64 %479, %412
br i1 %480, label %481, label %432
481: ; preds = %432, %431
%482 = phi i64 [ 0, %431 ], [ %478, %432 ]
br i1 %413, label %499, label %483
483: ; preds = %481, %483
%484 = phi i64 [ %496, %483 ], [ %482, %481 ]
%485 = phi i64 [ %497, %483 ], [ 0, %481 ]
%486 = getelementptr inbounds i32, i32* %421, i64 %484
%487 = bitcast i32* %486 to <4 x i32>*
%488 = load <4 x i32>, <4 x i32>* %487
%489 = getelementptr inbounds i32, i32* %486, i64 4
%490 = bitcast i32* %489 to <4 x i32>*
%491 = load <4 x i32>, <4 x i32>* %490
%492 = getelementptr inbounds i32, i32* %424, i64 %484
%493 = bitcast i32* %492 to <4 x i32>*
store <4 x i32> %488, <4 x i32>* %493
%494 = getelementptr inbounds i32, i32* %492, i64 4
%495 = bitcast i32* %494 to <4 x i32>*
store <4 x i32> %491, <4 x i32>* %495
%496 = add nuw i64 %484, 8
%497 = add i64 %485, 1
%498 = icmp eq i64 %497, %410
br i1 %498, label %499, label %483
499: ; preds = %483, %481
br i1 %414, label %547, label %500
500: ; preds = %425, %419, %499
%501 = phi i64 [ 0, %425 ], [ 0, %419 ], [ %409, %499 ]
%502 = xor i64 %501, -1
%503 = add nsw i64 %502, %403
br i1 %416, label %513, label %504
504: ; preds = %500, %504
%505 = phi i64 [ %510, %504 ], [ %501, %500 ]
%506 = phi i64 [ %511, %504 ], [ 0, %500 ]
%507 = getelementptr inbounds i32, i32* %421, i64 %505
%508 = load i32, i32* %507
%509 = getelementptr inbounds i32, i32* %424, i64 %505
store i32 %508, i32* %509
%510 = add nuw nsw i64 %505, 1
%511 = add i64 %506, 1
%512 = icmp eq i64 %511, %415
br i1 %512, label %513, label %504
513: ; preds = %504, %500
%514 = phi i64 [ %501, %500 ], [ %510, %504 ]
%515 = icmp ult i64 %503, 3
br i1 %515, label %547, label %528
516: ; preds = %547, %398
%517 = add nsw i32 %246, 1
%518 = icmp slt i32 %517, %14
br i1 %518, label %519, label %601
519: ; preds = %516
%520 = sext i32 %246 to i64
%521 = add nsw i64 %520, 1
%522 = zext i32 %1 to i64
%523 = add nsw i64 %522, -1
%524 = and i64 %522, 3
%525 = icmp ult i64 %523, 3
%526 = and i64 %522, 4294967292
%527 = icmp eq i64 %524, 0
br label %567
528: ; preds = %513, %528
%529 = phi i64 [ %545, %528 ], [ %514, %513 ]
%530 = getelementptr inbounds i32, i32* %421, i64 %529
%531 = load i32, i32* %530
%532 = getelementptr inbounds i32, i32* %424, i64 %529
store i32 %531, i32* %532
%533 = add nuw nsw i64 %529, 1
%534 = getelementptr inbounds i32, i32* %421, i64 %533
%535 = load i32, i32* %534
%536 = getelementptr inbounds i32, i32* %424, i64 %533
store i32 %535, i32* %536
%537 = add nuw nsw i64 %529, 2
%538 = getelementptr inbounds i32, i32* %421, i64 %537
%539 = load i32, i32* %538
%540 = getelementptr inbounds i32, i32* %424, i64 %537
store i32 %539, i32* %540
%541 = add nuw nsw i64 %529, 3
%542 = getelementptr inbounds i32, i32* %421, i64 %541
%543 = load i32, i32* %542
%544 = getelementptr inbounds i32, i32* %424, i64 %541
store i32 %543, i32* %544
%545 = add nuw nsw i64 %529, 4
%546 = icmp eq i64 %545, %403
br i1 %546, label %547, label %528
547: ; preds = %513, %528, %499, %417
%548 = add nuw nsw i64 %418, 1
%549 = icmp eq i64 %548, %402
br i1 %549, label %516, label %417
550: ; preds = %572, %571
%551 = phi i64 [ 0, %571 ], [ %598, %572 ]
br i1 %527, label %563, label %552
552: ; preds = %550, %552
%553 = phi i64 [ %560, %552 ], [ %551, %550 ]
%554 = phi i64 [ %561, %552 ], [ 0, %550 ]
%555 = getelementptr inbounds i32*, i32** %0, i64 %553
%556 = load i32*, i32** %555
%557 = getelementptr inbounds i32, i32* %556, i64 %569
%558 = load i32, i32* %557
%559 = getelementptr inbounds i32, i32* %556, i64 %568
store i32 %558, i32* %559
%560 = add nuw nsw i64 %553, 1
%561 = add i64 %554, 1
%562 = icmp eq i64 %561, %524
br i1 %562, label %563, label %552
563: ; preds = %550, %552, %567
%564 = add nsw i64 %569, 1
%565 = trunc i64 %564 to i32
%566 = icmp eq i32 %14, %565
br i1 %566, label %601, label %567
567: ; preds = %519, %563
%568 = phi i64 [ %520, %519 ], [ %570, %563 ]
%569 = phi i64 [ %521, %519 ], [ %564, %563 ]
%570 = add nsw i64 %568, 1
br i1 %377, label %571, label %563
571: ; preds = %567
br i1 %525, label %550, label %572
572: ; preds = %571, %572
%573 = phi i64 [ %598, %572 ], [ 0, %571 ]
%574 = phi i64 [ %599, %572 ], [ 0, %571 ]
%575 = getelementptr inbounds i32*, i32** %0, i64 %573
%576 = load i32*, i32** %575
%577 = getelementptr inbounds i32, i32* %576, i64 %569
%578 = load i32, i32* %577
%579 = getelementptr inbounds i32, i32* %576, i64 %568
store i32 %578, i32* %579
%580 = or i64 %573, 1
%581 = getelementptr inbounds i32*, i32** %0, i64 %580
%582 = load i32*, i32** %581
%583 = getelementptr inbounds i32, i32* %582, i64 %569
%584 = load i32, i32* %583
%585 = getelementptr inbounds i32, i32* %582, i64 %568
store i32 %584, i32* %585
%586 = or i64 %573, 2
%587 = getelementptr inbounds i32*, i32** %0, i64 %586
%588 = load i32*, i32** %587
%589 = getelementptr inbounds i32, i32* %588, i64 %569
%590 = load i32, i32* %589
%591 = getelementptr inbounds i32, i32* %588, i64 %568
store i32 %590, i32* %591
%592 = or i64 %573, 3
%593 = getelementptr inbounds i32*, i32** %0, i64 %592
%594 = load i32*, i32** %593
%595 = getelementptr inbounds i32, i32* %594, i64 %569
%596 = load i32, i32* %595
%597 = getelementptr inbounds i32, i32* %594, i64 %568
store i32 %596, i32* %597
%598 = add nuw nsw i64 %573, 4
%599 = add i64 %574, 4
%600 = icmp eq i64 %599, %526
br i1 %600, label %550, label %572
601: ; preds = %48, %563, %516
%602 = phi i32 [ 0, %516 ], [ 0, %563 ], [ 1, %48 ]
ret i32 %602
}