double inversion_matrice(int nb_dimensions, double **matrice) {
  int i, j, k, pivot;
  double **matrice_inverse, valeur;
  double determinant;
  matrice_inverse = (double **)malloc(sizeof(double *) * nb_dimensions);
  for (i = 0; i < nb_dimensions; i++) {
    matrice_inverse[i] = (double *)malloc(sizeof(double) * nb_dimensions);
  }
  for (i = 0; i < nb_dimensions; i++) {
    for (j = 0; j < nb_dimensions; j++) {
      matrice_inverse[i][j] = 0;
    }
    matrice_inverse[i][i] = 1.0;
  }
  determinant = 0.0;
  for (i = 0; i < nb_dimensions; i++) {
    pivot = -1;
    for (j = i; j < nb_dimensions; j++) {
      if (fabs(matrice[j][i]) > 0.000001) {
        pivot = j;
        break;
      }
    }
    if (pivot == -1) {
      return 0.0;
    }
    echange_lignes(nb_dimensions, matrice, i, pivot);
    echange_lignes(nb_dimensions, matrice_inverse, i, pivot);
    valeur = matrice[i][i];
    for (j = 0; j < nb_dimensions; j++) {
      matrice[i][j] /= valeur;
      matrice_inverse[i][j] /= valeur;
    }
    determinant += log(fabs(valeur));
    for (j = 0; j < nb_dimensions; j++) {
      if (j != i) {
        valeur = matrice[j][i];
        for (k = 0; k < nb_dimensions; k++) {
          matrice[j][k] -= valeur * matrice[i][k];
          matrice_inverse[j][k] -= valeur * matrice_inverse[i][k];
        }
      }
    }
  }
  for (i = 0; i < nb_dimensions; i++) {
    for (j = 0; j < nb_dimensions; j++) {
      matrice[i][j] = matrice_inverse[i][j];
    }
  }
  for (i = 0; i < nb_dimensions; i++) {
    free(matrice_inverse[i]);
  }
  free(matrice_inverse);
  return determinant;
}


x86 assembly (clang, -O0):
<inversion_matrice>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
movslq -0xc(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    119d <inversion_matrice+0x5d>
movslq -0xc(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1167 <inversion_matrice+0x27>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1214 <inversion_matrice+0xd4>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11e9 <inversion_matrice+0xa9>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11b7 <inversion_matrice+0x77>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  0xe07(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11a4 <inversion_matrice+0x64>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14a2 <inversion_matrice+0x362>
movl   $0xffffffff,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1298 <inversion_matrice+0x158>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdac(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xd90(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1285 <inversion_matrice+0x145>
mov    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    1298 <inversion_matrice+0x158>
jmp    128a <inversion_matrice+0x14a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    123c <inversion_matrice+0xfc>
cmpl   $0xffffffff,-0x28(%rbp)
jne    12af <inversion_matrice+0x16f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1558 <inversion_matrice+0x418>
mov    -0xc(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    $0x0,%al
call   1040 <echange_lignes@plt>
mov    -0xc(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    $0x0,%al
call   1040 <echange_lignes@plt>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1358 <inversion_matrice+0x218>
movsd  -0x38(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12f8 <inversion_matrice+0x1b8>
movsd  -0x38(%rbp),%xmm0
movaps 0xcac(%rip),%xmm1
pand   %xmm1,%xmm0
call   1060 <log@plt>
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    148f <inversion_matrice+0x34f>
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     147c <inversion_matrice+0x33c>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1477 <inversion_matrice+0x337>
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13b7 <inversion_matrice+0x277>
jmp    147c <inversion_matrice+0x33c>
jmp    1481 <inversion_matrice+0x341>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    137e <inversion_matrice+0x23e>
jmp    1494 <inversion_matrice+0x354>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1223 <inversion_matrice+0xe3>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1513 <inversion_matrice+0x3d3>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1500 <inversion_matrice+0x3c0>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14bc <inversion_matrice+0x37c>
jmp    1505 <inversion_matrice+0x3c5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14a9 <inversion_matrice+0x369>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1545 <inversion_matrice+0x405>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    151a <inversion_matrice+0x3da>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inversion_matrice>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rsi,0x18(%rsp)
mov    %edi,%r15d
movslq %edi,%rbx
lea    0x0(,%rbx,8),%rbp
mov    %rbp,%rdi
call   1060 <malloc@plt>
mov    %rax,%r13
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
test   %ebx,%ebx
jle    1978 <inversion_matrice+0x828>
mov    %r15d,%r14d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbp,%rdi
call   1060 <malloc@plt>
mov    %rax,0x0(%r13,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    11a0 <inversion_matrice+0x50>
test   %r15d,%r15d
jle    1978 <inversion_matrice+0x828>
mov    %r15d,0xc(%rsp)
lea    0x0(,%r14,8),%r12
lea    -0x1(%r14),%rax
mov    %r14d,%ebp
and    $0x3,%ebp
mov    %r14,%rcx
movabs $0x3ff0000000000000,%r14
cmp    $0x3,%rax
mov    %rcx,0x58(%rsp)
jae    11f6 <inversion_matrice+0xa6>
mov    %r13,%r15
xor    %r13d,%r13d
jmp    1275 <inversion_matrice+0x125>
and    $0xfffffffc,%ecx
mov    %rcx,0x28(%rsp)
mov    %r13,%r15
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r15,%r13,8),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
mov    %r14,(%rbx,%r13,8)
mov    0x8(%r15,%r13,8),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
mov    %r14,0x8(%rbx,%r13,8)
mov    0x10(%r15,%r13,8),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
mov    %r14,0x10(%rbx,%r13,8)
mov    0x18(%r15,%r13,8),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
mov    %r14,0x18(%rbx,%r13,8)
add    $0x4,%r13
cmp    %r13,0x28(%rsp)
jne    1210 <inversion_matrice+0xc0>
test   %rbp,%rbp
je     129f <inversion_matrice+0x14f>
nopw   0x0(%rax,%rax,1)
mov    (%r15,%r13,8),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
mov    %r14,(%rbx,%r13,8)
add    $0x1,%r13
add    $0xffffffffffffffff,%rbp
jne    1280 <inversion_matrice+0x130>
mov    0xc(%rsp),%edi
test   %edi,%edi
mov    %r15,%r13
jle    1978 <inversion_matrice+0x828>
mov    0x58(%rsp),%r14
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x48(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x30(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0x60(%rsp)
xorpd  %xmm4,%xmm4
movapd 0xd07(%rip),%xmm1
movsd  0xd1f(%rip),%xmm5
xor    %edx,%edx
mov    0x18(%rsp),%r15
mov    %rdx,%rbp
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbp,8),%rax
movsd  (%rax,%rdx,8),%xmm0
andpd  %xmm1,%xmm0
ucomisd %xmm5,%xmm0
ja     1340 <inversion_matrice+0x1f0>
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1310 <inversion_matrice+0x1c0>
jmp    178e <inversion_matrice+0x63e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm4,0x20(%rsp)
mov    %r15,%rsi
mov    %ebp,%ecx
xor    %eax,%eax
mov    %rdx,0x10(%rsp)
mov    %edi,%ebx
call   1050 <echange_lignes@plt>
mov    %ebx,%edi
mov    %r13,%rsi
mov    0x10(%rsp),%rdx
mov    %ebp,%ecx
xor    %eax,%eax
call   1050 <echange_lignes@plt>
mov    %ebx,%edx
mov    0x10(%rsp),%rcx
mov    (%r15,%rcx,8),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x0(%r13,%rcx,8),%rcx
cmp    $0x2,%ebx
mov    %r13,0x50(%rsp)
jae    1392 <inversion_matrice+0x242>
xor    %edx,%edx
jmp    1450 <inversion_matrice+0x300>
lea    (%rcx,%r14,8),%rdx
cmp    %rdx,%rax
jae    13ab <inversion_matrice+0x25b>
lea    (%rax,%r14,8),%rdx
cmp    %rdx,%rcx
jae    13ab <inversion_matrice+0x25b>
xor    %edx,%edx
jmp    1450 <inversion_matrice+0x300>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x40(%rsp)
je     177c <inversion_matrice+0x62c>
mov    0x30(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd (%rax,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rdx,8)
movupd (%rcx,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rcx,%rdx,8)
movupd 0x10(%rax,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,0x10(%rax,%rdx,8)
movupd 0x10(%rcx,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,0x10(%rcx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    13d0 <inversion_matrice+0x280>
testb  $0x1,0x38(%rsp)
je     1439 <inversion_matrice+0x2e9>
movupd (%rax,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rdx,8)
movupd (%rcx,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rcx,%rdx,8)
mov    0x48(%rsp),%rsi
mov    %rsi,%rdx
cmp    %r14,%rsi
je     1475 <inversion_matrice+0x325>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rdx,8)
movsd  (%rcx,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    1450 <inversion_matrice+0x300>
andpd  0xb83(%rip),%xmm0
call   1070 <log@plt>
movsd  0x20(%rsp),%xmm4
addsd  %xmm0,%xmm4
xor    %eax,%eax
movsd  0xb8a(%rip),%xmm5
movapd 0xb72(%rip),%xmm6
mov    0x10(%rsp),%rdx
mov    %ebx,%edi
jmp    14bd <inversion_matrice+0x36d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r14,%rax
je     1760 <inversion_matrice+0x610>
cmp    %rdx,%rax
je     14b0 <inversion_matrice+0x360>
mov    (%r15,%rax,8),%rcx
mov    (%r15,%rdx,8),%r12
movsd  (%rcx,%rdx,8),%xmm0
xorpd  %xmm6,%xmm0
mov    0x50(%rsp),%rbp
mov    0x0(%rbp,%rdx,8),%rsi
mov    0x0(%rbp,%rax,8),%r13
cmp    $0x2,%edi
jae    15b0 <inversion_matrice+0x460>
xor    %ebx,%ebx
mov    %rbx,%rbp
test   $0x1,%r14b
je     1528 <inversion_matrice+0x3d8>
movsd  (%r12,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rbx,8),%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
movsd  (%rsi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%r13,%rbx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rbx,8)
mov    %rbx,%rbp
or     $0x1,%rbp
not    %rbx
cmp    0x60(%rsp),%rbx
je     14b0 <inversion_matrice+0x360>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rbp,8),%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
movsd  (%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%r13,%rbp,8),%xmm1
movsd  %xmm1,0x0(%r13,%rbp,8)
movsd  0x8(%r12,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rbp,8)
movsd  0x8(%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r13,%rbp,8),%xmm1
movsd  %xmm1,0x8(%r13,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r14
jne    1540 <inversion_matrice+0x3f0>
jmp    14b0 <inversion_matrice+0x360>
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%r14,8),%rbp
lea    0x0(,%r14,8),%rbx
add    %r13,%rbx
lea    (%r12,%r14,8),%r8
lea    (%rsi,%r14,8),%r15
cmp    %rbx,%rcx
setb   0x28(%rsp)
cmp    %rbp,%r13
setb   %dl
cmp    %r8,%rcx
setb   %r11b
cmp    %rbp,%r12
setb   %dil
cmp    %r15,%rcx
setb   %r9b
cmp    %rbp,%rsi
setb   %bpl
cmp    %r8,%r13
setb   %r10b
cmp    %rbx,%r12
setb   0x20(%rsp)
cmp    %r15,%r13
setb   %r8b
cmp    %rbx,%rsi
setb   %r15b
test   %dl,0x28(%rsp)
jne    1743 <inversion_matrice+0x5f3>
and    %dil,%r11b
jne    1743 <inversion_matrice+0x5f3>
and    %bpl,%r9b
mov    0xc(%rsp),%edi
jne    1734 <inversion_matrice+0x5e4>
and    0x20(%rsp),%r10b
jne    1734 <inversion_matrice+0x5e4>
mov    $0x0,%ebx
and    %r15b,%r8b
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%rdx
jne    14ed <inversion_matrice+0x39d>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x40(%rsp)
je     1738 <inversion_matrice+0x5e8>
mov    0x30(%rsp),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd (%r12,%rbp,8),%xmm2
movupd (%rcx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%rcx,%rbp,8)
movupd (%rsi,%rbp,8),%xmm2
movupd 0x0(%r13,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x0(%r13,%rbp,8)
movupd 0x10(%r12,%rbp,8),%xmm2
movupd 0x10(%rcx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x10(%rcx,%rbp,8)
movupd 0x10(%rsi,%rbp,8),%xmm2
movupd 0x10(%r13,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x10(%r13,%rbp,8)
add    $0x4,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1670 <inversion_matrice+0x520>
testb  $0x1,0x38(%rsp)
je     171e <inversion_matrice+0x5ce>
movupd (%r12,%rbp,8),%xmm2
movupd (%rcx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%rcx,%rbp,8)
movupd (%rsi,%rbp,8),%xmm2
movupd 0x0(%r13,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x0(%r13,%rbp,8)
mov    0x48(%rsp),%rbp
mov    %rbp,%rbx
cmp    %r14,%rbp
je     14b0 <inversion_matrice+0x360>
jmp    14ed <inversion_matrice+0x39d>
xor    %ebx,%ebx
jmp    1749 <inversion_matrice+0x5f9>
xor    %ebp,%ebp
testb  $0x1,0x38(%rsp)
jne    16eb <inversion_matrice+0x59b>
jmp    171e <inversion_matrice+0x5ce>
xor    %ebx,%ebx
mov    0xc(%rsp),%edi
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%rdx
jmp    14ed <inversion_matrice+0x39d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r14,%rdx
movapd 0x891(%rip),%xmm1
mov    0x50(%rsp),%r13
jne    1308 <inversion_matrice+0x1b8>
jmp    1797 <inversion_matrice+0x647>
xor    %edx,%edx
testb  $0x1,0x38(%rsp)
jne    141d <inversion_matrice+0x2cd>
jmp    1439 <inversion_matrice+0x2e9>
xorpd  %xmm0,%xmm0
jmp    1986 <inversion_matrice+0x836>
test   %edi,%edi
jle    1972 <inversion_matrice+0x822>
mov    %edi,%r12d
mov    %r14d,%r10d
and    $0xfffffffc,%r10d
add    $0xfffffffffffffffc,%r10
mov    %r10,%r8
shr    $0x2,%r8
add    $0x1,%r8
mov    %r14d,%r11d
and    $0xfffffffc,%r11d
mov    %r8d,%r9d
and    $0x3,%r9d
and    $0xfffffffffffffffc,%r8
mov    %r14d,%r15d
and    $0x3,%r15d
mov    %r9,%rsi
shl    $0x5,%rsi
xor    %ebx,%ebx
jmp    17e9 <inversion_matrice+0x699>
add    $0x1,%rbx
cmp    %r14,%rbx
je     1950 <inversion_matrice+0x800>
mov    0x0(%r13,%rbx,8),%rbp
mov    0x18(%rsp),%rax
mov    (%rax,%rbx,8),%rcx
cmp    $0x4,%r14d
jb     181a <inversion_matrice+0x6ca>
lea    0x0(,%r14,8),%rax
add    %rbp,%rax
cmp    %rax,%rcx
jae    188d <inversion_matrice+0x73d>
lea    (%rcx,%r14,8),%rax
cmp    %rax,%rbp
jae    188d <inversion_matrice+0x73d>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %r14,%rax
test   %r15,%r15
je     1845 <inversion_matrice+0x6f5>
mov    %r15,%rdi
nopl   (%rax)
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1830 <inversion_matrice+0x6e0>
cmp    $0x3,%rax
jb     17dc <inversion_matrice+0x68c>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x8(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
movsd  0x10(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rdx,8)
movsd  0x18(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r14
jne    1850 <inversion_matrice+0x700>
jmp    17dc <inversion_matrice+0x68c>
cmp    $0xc,%r10
jae    1897 <inversion_matrice+0x747>
xor    %edx,%edx
jmp    18fd <inversion_matrice+0x7ad>
mov    %r8,%rax
xor    %edx,%edx
nopl   0x0(%rax)
movups 0x0(%rbp,%rdx,8),%xmm0
movups 0x10(%rbp,%rdx,8),%xmm1
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
movups 0x20(%rbp,%rdx,8),%xmm0
movups 0x30(%rbp,%rdx,8),%xmm1
movups %xmm0,0x20(%rcx,%rdx,8)
movups %xmm1,0x30(%rcx,%rdx,8)
movups 0x40(%rbp,%rdx,8),%xmm0
movups 0x50(%rbp,%rdx,8),%xmm1
movups %xmm0,0x40(%rcx,%rdx,8)
movups %xmm1,0x50(%rcx,%rdx,8)
movupd 0x60(%rbp,%rdx,8),%xmm0
movupd 0x70(%rbp,%rdx,8),%xmm1
movupd %xmm0,0x60(%rcx,%rdx,8)
movupd %xmm1,0x70(%rcx,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rax
jne    18a0 <inversion_matrice+0x750>
test   %r9,%r9
je     193f <inversion_matrice+0x7ef>
lea    (%rcx,%rdx,8),%rax
add    $0x10,%rax
lea    0x10(,%rdx,8),%rdx
add    %rbp,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rdi,1),%xmm0
movupd (%rdx,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rax,%rdi,1)
movupd %xmm1,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1920 <inversion_matrice+0x7d0>
mov    %r11,%rdx
cmp    %r14,%r11
je     17dc <inversion_matrice+0x68c>
jmp    181c <inversion_matrice+0x6cc>
movsd  %xmm4,0x20(%rsp)
test   %r12d,%r12d
jle    1978 <inversion_matrice+0x828>
xor    %ebx,%ebx
mov    0x0(%r13,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    195d <inversion_matrice+0x80d>
jmp    1978 <inversion_matrice+0x828>
movsd  %xmm4,0x20(%rsp)
mov    %r13,%rdi
call   1030 <free@plt>
movsd  0x20(%rsp),%xmm0
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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