void use_free_neuron(int nr, int ncl, int nf, int *classe, double **m,
                     double **w) {
  double **centroide = (double **)malloc(ncl * sizeof(double *));
  int ff;
  for (ff = 0; ff < ncl; ff++) {
    centroide[ff] = (double *)malloc(nf * sizeof(double));
  }
  double **distcentro = (double **)malloc(ncl * sizeof(double *));
  int ff2;
  for (ff2 = 0; ff2 < ncl; ff2++) {
    distcentro[ff2] = (double *)malloc(nr * sizeof(double));
  }
  double *vet = (double *)malloc(nr * sizeof(double));
  double *riduzione = (double *)malloc(ncl * sizeof(double));
  double *ncasi = (double *)malloc(ncl * sizeof(double));
  double *nfree = (double *)malloc(ncl * sizeof(double));
  double *nrid = (double *)malloc(ncl * sizeof(double));
  int n = ncl;
  int ncasi_attuali = nr;
  int nfeatures_attuali = nf;
  int nfeatures_iniziali = nf;
  int ncasi_iniziali = nr;
  int nc;
  int i, j;
  int k;
  int m1;
  double ridmax;
  int nlib, nmax;
  int i1;
  double vetm, vetxqm;
  for (j = 0; j < n; j++)
    for (i = 0; i < nr; i++) {
      distcentro[j][i] = 0;
    }
  for (j = 0; j < n; j++) {
    nc = 0;
    for (i = 0; i < nfeatures_iniziali; i++)
      centroide[j][i] = 0.0;
    for (i = 0; i < ncasi_attuali; i++)
      if (classe[i] == j) {
        nc = nc + 1;
        k = i;
        for (m1 = 0; m1 < nfeatures_iniziali; m1++)
          centroide[j][m1] = centroide[j][m1] + m[k][m1];
      }
    ncasi[j] = nc;
    for (m1 = 0; m1 < nfeatures_iniziali; m1++)
      if (nc != 0)
        centroide[j][m1] = centroide[j][m1] / nc;
  }
  do {
    ridmax = 0;
    nlib = 0;
    nmax = 0;
    for (j = 0; j < n; j++) {
      nc = 0;
      for (i = 0; i < ncasi_attuali; i++) {
        distcentro[j][i] = 0.0;
        if (classe[i] == j) {
          nc = nc + 1;
          k = i;
          for (m1 = 0; m1 < nfeatures_iniziali; m1++)
            distcentro[j][i] =
                distcentro[j][i] +
                (m[k][m1] - centroide[j][m1]) * (m[k][m1] - centroide[j][m1]);
          distcentro[j][i] = sqrt(distcentro[j][i]) / nfeatures_attuali;
        }
      }
      i1 = -1;
      for (i = 0; i < ncasi_attuali; i++)
        if (classe[i] == j) {
          i1 = i1 + 1;
          vet[i1] = distcentro[j][i];
        }
      if (i1 == -1 && nfree[j] == 0) {
        nlib = j;
        nfree[j] = 1;
      }
      riduzione[j] = 0;
      if (i1 != -1) {
        vetm = 0;
        vetxqm = 0;
        vetm = statm(vet, i1);
        vetxqm = statds(vet, vetm, i1);
        riduzione[j] = vetm * (1 + vetxqm);
      }
      if (riduzione[j] > ridmax && nrid[j] == 0) {
        ridmax = riduzione[j];
        nmax = j;
      }
    }
    if (nmax != 0)
      nrid[nmax] = 1;
    if (nlib != 0 && nmax != 0)
      for (i = 0; i < nr; i++)
        w[i][nlib] = w[i][nmax];
  } while (nlib != 0 && nmax != 0);
  free(centroide);
  free(distcentro);
  free(vet);
  free(riduzione);
  free(ncasi);
  free(nfree);
  free(nrid);
}


x86 assembly (clang, -O0):
<use_free_neuron>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movslq -0x8(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11be <use_free_neuron+0x6e>
movslq -0xc(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1188 <use_free_neuron+0x38>
movslq -0x8(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    120c <use_free_neuron+0xbc>
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11d6 <use_free_neuron+0x86>
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x8(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x8(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x8(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x8(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x84(%rbp)
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    12ff <use_free_neuron+0x1af>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12e6 <use_free_neuron+0x196>
mov    -0x40(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    12a5 <use_free_neuron+0x155>
jmp    12eb <use_free_neuron+0x19b>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    128c <use_free_neuron+0x13c>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1509 <use_free_neuron+0x3b9>
movl   $0x0,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x80(%rbp),%eax
jge    136d <use_free_neuron+0x21d>
mov    -0x30(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    132c <use_free_neuron+0x1dc>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1457 <use_free_neuron+0x307>
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x90(%rbp),%eax
jne    143e <use_free_neuron+0x2ee>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x80(%rbp),%eax
jge    1439 <use_free_neuron+0x2e9>
mov    -0x30(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    13c5 <use_free_neuron+0x275>
jmp    143e <use_free_neuron+0x2ee>
jmp    1443 <use_free_neuron+0x2f3>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1377 <use_free_neuron+0x227>
cvtsi2sdl -0x88(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x80(%rbp),%eax
jge    14f0 <use_free_neuron+0x3a0>
cmpl   $0x0,-0x88(%rbp)
je     14d7 <use_free_neuron+0x387>
mov    -0x30(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x88(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    14dc <use_free_neuron+0x38c>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1479 <use_free_neuron+0x329>
jmp    14f5 <use_free_neuron+0x3a5>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1309 <use_free_neuron+0x1b9>
jmp    150e <use_free_neuron+0x3be>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0xa4(%rbp)
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    18f6 <use_free_neuron+0x7a6>
movl   $0x0,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    16f0 <use_free_neuron+0x5a0>
mov    -0x40(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x90(%rbp),%eax
jne    16d7 <use_free_neuron+0x587>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x80(%rbp),%eax
jge    1693 <use_free_neuron+0x543>
mov    -0x40(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    15c6 <use_free_neuron+0x476>
mov    -0x40(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1070 <sqrt@plt>
cvtsi2sdl -0x7c(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16dc <use_free_neuron+0x58c>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    155a <use_free_neuron+0x40a>
movl   $0xffffffff,-0xac(%rbp)
ff ff ff
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1780 <use_free_neuron+0x630>
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x90(%rbp),%eax
jne    1767 <use_free_neuron+0x617>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    176c <use_free_neuron+0x61c>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1704 <use_free_neuron+0x5b4>
cmpl   $0xffffffff,-0xac(%rbp)
jne    17d4 <use_free_neuron+0x684>
mov    -0x68(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17d4 <use_free_neuron+0x684>
jp     17d4 <use_free_neuron+0x684>
mov    -0x90(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  0x831(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x90(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0xffffffff,-0xac(%rbp)
je     1878 <use_free_neuron+0x728>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x50(%rbp),%rdi
mov    -0xac(%rbp),%esi
mov    $0x0,%al
call   1050 <statm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x50(%rbp),%rdi
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0xac(%rbp),%esi
mov    $0x1,%al
call   1030 <statds@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0x7a4(%rip),%xmm1
addsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    18dd <use_free_neuron+0x78d>
mov    -0x70(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18dd <use_free_neuron+0x78d>
jp     18dd <use_free_neuron+0x78d>
mov    -0x58(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x90(%rbp),%eax
mov    %eax,-0xa8(%rbp)
jmp    18e2 <use_free_neuron+0x792>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1537 <use_free_neuron+0x3e7>
cmpl   $0x0,-0xa8(%rbp)
je     191b <use_free_neuron+0x7cb>
mov    -0x70(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  0x6ea(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0xa4(%rbp)
je     199d <use_free_neuron+0x84d>
cmpl   $0x0,-0xa8(%rbp)
je     199d <use_free_neuron+0x84d>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1998 <use_free_neuron+0x848>
mov    -0x28(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    193f <use_free_neuron+0x7ef>
jmp    199d <use_free_neuron+0x84d>
jmp    19a2 <use_free_neuron+0x852>
xor    %eax,%eax
cmpl   $0x0,-0xa4(%rbp)
mov    %al,-0xc1(%rbp)
je     19c7 <use_free_neuron+0x877>
cmpl   $0x0,-0xa8(%rbp)
setne  %al
mov    %al,-0xc1(%rbp)
mov    -0xc1(%rbp),%al
test   $0x1,%al
jne    150e <use_free_neuron+0x3be>
mov    -0x30(%rbp),%rdi
call   1040 <free@plt>
mov    -0x40(%rbp),%rdi
call   1040 <free@plt>
mov    -0x50(%rbp),%rdi
call   1040 <free@plt>
mov    -0x58(%rbp),%rdi
call   1040 <free@plt>
mov    -0x60(%rbp),%rdi
call   1040 <free@plt>
mov    -0x68(%rbp),%rdi
call   1040 <free@plt>
mov    -0x70(%rbp),%rdi
call   1040 <free@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<use_free_neuron>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,0xa0(%rsp)
mov    %r8,0x88(%rsp)
mov    %rcx,0x30(%rsp)
mov    %edx,%r14d
mov    %esi,%ebp
mov    %edi,%r15d
movslq %esi,%rbx
lea    0x0(,%rbx,8),%r13
mov    %r13,%rdi
call   1070 <malloc@plt>
mov    %ebp,0x14(%rsp)
mov    %ebp,%r12d
mov    %r15d,0xc(%rsp)
movslq %r15d,%r15
test   %ebx,%ebx
mov    %r14d,0x10(%rsp)
mov    %rax,0x20(%rsp)
mov    %r12,0x78(%rsp)
jle    1238 <use_free_neuron+0xd8>
mov    %r15,0x28(%rsp)
mov    %r13,%r15
movslq %r14d,%r13
shl    $0x3,%r13
xor    %ebx,%ebx
mov    %rax,%rbp
nopw   0x0(%rax,%rax,1)
mov    %r13,%rdi
call   1070 <malloc@plt>
mov    %rax,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    11e0 <use_free_neuron+0x80>
mov    %r15,%r13
mov    %r15,%rdi
call   1070 <malloc@plt>
cmpl   $0x0,0x14(%rsp)
mov    %rax,0x18(%rsp)
jle    1247 <use_free_neuron+0xe7>
mov    0x28(%rsp),%r15
shl    $0x3,%r15
xor    %ebx,%ebx
mov    %rax,%rbp
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdi
call   1070 <malloc@plt>
mov    %rax,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1220 <use_free_neuron+0xc0>
jmp    1250 <use_free_neuron+0xf0>
mov    %r13,%rdi
call   1070 <malloc@plt>
mov    %rax,0x18(%rsp)
jmp    124c <use_free_neuron+0xec>
mov    0x28(%rsp),%r15
shl    $0x3,%r15
mov    %r15,%rdi
call   1070 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %r13,%rdi
call   1070 <malloc@plt>
mov    %rax,0x80(%rsp)
mov    %r13,%rdi
call   1070 <malloc@plt>
mov    %rax,0x70(%rsp)
mov    0xc(%rsp),%r11d
mov    0x10(%rsp),%r9d
mov    %r9d,%r12d
cmpl   $0x0,0x14(%rsp)
mov    0x30(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    %r11,0x38(%rsp)
jle    161c <use_free_neuron+0x4bc>
lea    0x0(,%r11,8),%r13
mov    0x78(%rsp),%rbx
lea    -0x1(%rbx),%rax
mov    %ebx,%r14d
and    $0x3,%r14d
cmp    $0x3,%rax
jae    1a9f <use_free_neuron+0x93f>
xor    %ebp,%ebp
test   %r14,%r14
je     1314 <use_free_neuron+0x1b4>
mov    0x18(%rsp),%rax
lea    (%rax,%rbp,8),%rbx
xor    %ebp,%ebp
jmp    12e9 <use_free_neuron+0x189>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %rbp,%r14
je     1314 <use_free_neuron+0x1b4>
cmpl   $0x0,0xc(%rsp)
jle    12e0 <use_free_neuron+0x180>
mov    (%rbx,%rbp,8),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1060 <memset@plt>
mov    0x38(%rsp),%r11
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%r9d
mov    0x30(%rsp),%r8
jmp    12e0 <use_free_neuron+0x180>
cmpl   $0x0,0x14(%rsp)
jle    161c <use_free_neuron+0x4bc>
lea    0x0(,%r12,8),%rax
mov    %rax,0x60(%rsp)
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x40(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x58(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
lea    -0x1(%r12),%rax
mov    %rax,0x28(%rsp)
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x68(%rsp)
mov    %r12d,%r13d
and    $0x3,%r13d
mov    %r12d,%r14d
and    $0xfffffffe,%r14d
xor    %r15d,%r15d
jmp    138f <use_free_neuron+0x22f>
nopl   0x0(%rax)
add    $0x1,%r15
cmp    0x78(%rsp),%r15
je     161c <use_free_neuron+0x4bc>
test   %r9d,%r9d
jle    13b8 <use_free_neuron+0x258>
mov    (%rdi,%r15,8),%rdi
xor    %esi,%esi
mov    0x60(%rsp),%rdx
call   1060 <memset@plt>
mov    0x38(%rsp),%r11
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%r9d
mov    0x30(%rsp),%r8
cmpl   $0x0,0xc(%rsp)
jle    1590 <use_free_neuron+0x430>
xor    %ecx,%ecx
xor    %r10d,%r10d
jmp    13dd <use_free_neuron+0x27d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r11,%rcx
je     1593 <use_free_neuron+0x433>
mov    (%r8,%rcx,4),%edx
cmp    %rdx,%r15
jne    13d0 <use_free_neuron+0x270>
add    $0x1,%r10d
test   %r9d,%r9d
jle    13d0 <use_free_neuron+0x270>
mov    (%rdi,%r15,8),%rdx
mov    0x88(%rsp),%rsi
mov    (%rsi,%rcx,8),%rsi
cmp    $0x4,%r9d
jb     141f <use_free_neuron+0x2bf>
lea    (%rsi,%r12,8),%rax
cmp    %rax,%rdx
jae    14c3 <use_free_neuron+0x363>
lea    (%rdx,%r12,8),%rax
cmp    %rax,%rsi
jae    14c3 <use_free_neuron+0x363>
xor    %eax,%eax
mov    0x28(%rsp),%rbx
sub    %rax,%rbx
test   %r13,%r13
je     1459 <use_free_neuron+0x2f9>
mov    %r13,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
jne    1440 <use_free_neuron+0x2e0>
cmp    $0x3,%rbx
jb     13d0 <use_free_neuron+0x270>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rax,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
movsd  0x8(%rdx,%rax,8),%xmm1
movsd  %xmm0,(%rdx,%rax,8)
addsd  0x8(%rsi,%rax,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rax,8)
movsd  0x10(%rdx,%rax,8),%xmm0
addsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rax,8)
movsd  0x18(%rdx,%rax,8),%xmm0
addsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    1470 <use_free_neuron+0x310>
jmp    13d0 <use_free_neuron+0x270>
cmpq   $0x0,0x58(%rsp)
je     1585 <use_free_neuron+0x425>
mov    0x68(%rsp),%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movupd (%rdx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rdx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%rdx,%rax,8),%xmm1
movupd 0x30(%rdx,%rax,8),%xmm3
movupd %xmm2,(%rdx,%rax,8)
movupd %xmm0,0x10(%rdx,%rax,8)
movupd 0x20(%rsi,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x30(%rsi,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rdx,%rax,8)
movupd %xmm1,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbx
jne    14e0 <use_free_neuron+0x380>
testb  $0x1,0x50(%rsp)
je     156f <use_free_neuron+0x40f>
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rdx,%rax,8)
movupd %xmm0,0x10(%rdx,%rax,8)
mov    0x40(%rsp),%rbx
mov    %rbx,%rax
cmp    %r12,%rbx
je     13d0 <use_free_neuron+0x270>
jmp    1421 <use_free_neuron+0x2c1>
xor    %eax,%eax
testb  $0x1,0x50(%rsp)
jne    1546 <use_free_neuron+0x3e6>
jmp    156f <use_free_neuron+0x40f>
xor    %r10d,%r10d
test   %r9d,%r9d
jle    1380 <use_free_neuron+0x220>
xorps  %xmm0,%xmm0
cvtsi2sd %r10d,%xmm0
cmpq   $0x0,0x28(%rsp)
je     15f0 <use_free_neuron+0x490>
xor    %ecx,%ecx
jmp    15b9 <use_free_neuron+0x459>
add    $0x2,%rcx
cmp    %rcx,%r14
je     15f2 <use_free_neuron+0x492>
test   %r10d,%r10d
je     15b0 <use_free_neuron+0x450>
mov    (%rdi,%r15,8),%rdx
movsd  (%rdx,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
mov    (%rdi,%r15,8),%rdx
movsd  0x8(%rdx,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdx,%rcx,8)
jmp    15b0 <use_free_neuron+0x450>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
test   $0x1,%r12b
je     1380 <use_free_neuron+0x220>
test   %r10d,%r10d
je     1380 <use_free_neuron+0x220>
mov    (%rdi,%r15,8),%rax
movsd  (%rax,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
jmp    1380 <use_free_neuron+0x220>
cmpl   $0x0,0x14(%rsp)
jle    1a5e <use_free_neuron+0x8fe>
xorps  %xmm0,%xmm0
cvtsi2sd %r9d,%xmm0
movsd  %xmm0,0x28(%rsp)
lea    -0x1(%r11),%rax
mov    %rax,0x50(%rsp)
mov    %r12d,%r15d
and    $0xfffffffe,%r15d
mov    %r11d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x98(%rsp)
mov    %r11d,%eax
and    $0x3,%eax
mov    %rax,0x68(%rsp)
mov    %r11d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x90(%rsp)
xorpd  %xmm2,%xmm2
xor    %r14d,%r14d
xor    %ebp,%ebp
xor    %esi,%esi
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x40(%rsp)
jmp    16b2 <use_free_neuron+0x552>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %r14d,%r14d
mov    $0x0,%ebp
mov    $0x0,%esi
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x40(%rsp)
cmpl   $0x0,0x14(%rsp)
jle    1a5e <use_free_neuron+0x8fe>
mov    %esi,0x58(%rsp)
cmpl   $0x0,0xc(%rsp)
jle    18f0 <use_free_neuron+0x790>
mov    %ebp,%r13d
mov    0x18(%rsp),%rax
mov    (%rax,%r14,8),%rbx
xor    %ebp,%ebp
jmp    1715 <use_free_neuron+0x5b5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
call   1080 <sqrt@plt>
xorpd  %xmm2,%xmm2
mov    0x38(%rsp),%r11
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%r9d
mov    0x30(%rsp),%r8
divsd  0x28(%rsp),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %r11,%rbp
je     17d0 <use_free_neuron+0x670>
movq   $0x0,(%rbx,%rbp,8)
mov    (%r8,%rbp,4),%eax
cmp    %rax,%r14
jne    1708 <use_free_neuron+0x5a8>
test   %r9d,%r9d
jle    17b2 <use_free_neuron+0x652>
mov    0x88(%rsp),%rax
mov    (%rax,%rbp,8),%rcx
mov    (%rdi,%r14,8),%rax
xorpd  %xmm0,%xmm0
xor    %edx,%edx
cmp    $0x1,%r9d
je     1789 <use_free_neuron+0x629>
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm1
subsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
movsd  0x8(%rcx,%rdx,8),%xmm0
subsd  0x8(%rax,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x2,%rdx
cmp    %rdx,%r15
jne    1750 <use_free_neuron+0x5f0>
test   $0x1,%r12b
je     17a6 <use_free_neuron+0x646>
movsd  (%rcx,%rdx,8),%xmm1
subsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
ucomisd %xmm2,%xmm0
jb     16e0 <use_free_neuron+0x580>
jmp    17c0 <use_free_neuron+0x660>
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
jb     16e0 <use_free_neuron+0x580>
sqrtsd %xmm0,%xmm0
jmp    16fd <use_free_neuron+0x59d>
nopl   0x0(%rax)
cmpl   $0x0,0xc(%rsp)
mov    %r13d,%ebp
jle    18f0 <use_free_neuron+0x790>
cmpq   $0x0,0x50(%rsp)
je     185b <use_free_neuron+0x6fb>
mov    $0xffffffff,%r13d
xor    %eax,%eax
mov    0x18(%rsp),%rdx
mov    0x48(%rsp),%rsi
mov    0x98(%rsp),%rdi
jmp    1819 <use_free_neuron+0x6b9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rax
cmp    %rax,%rdi
je     186d <use_free_neuron+0x70d>
mov    (%r8,%rax,4),%ecx
cmp    %rcx,%r14
jne    1838 <use_free_neuron+0x6d8>
mov    (%rdx,%r14,8),%rcx
movsd  (%rcx,%rax,8),%xmm0
movslq %r13d,%rcx
add    $0x1,%r13d
movsd  %xmm0,0x8(%rsi,%rcx,8)
mov    0x4(%r8,%rax,4),%ecx
cmp    %rcx,%r14
jne    1810 <use_free_neuron+0x6b0>
mov    (%rdx,%r14,8),%rcx
movsd  0x8(%rcx,%rax,8),%xmm0
movslq %r13d,%rcx
add    $0x1,%r13d
movsd  %xmm0,0x8(%rsi,%rcx,8)
jmp    1810 <use_free_neuron+0x6b0>
mov    $0xffffffff,%r13d
xor    %eax,%eax
mov    0x18(%rsp),%rdx
mov    0x48(%rsp),%rsi
test   $0x1,%r11b
je     1892 <use_free_neuron+0x732>
mov    (%r8,%rax,4),%ecx
cmp    %rcx,%r14
jne    1892 <use_free_neuron+0x732>
mov    (%rdx,%r14,8),%rcx
movsd  (%rcx,%rax,8),%xmm0
movslq %r13d,%rax
add    $0x1,%r13d
movsd  %xmm0,0x8(%rsi,%rax,8)
cmp    $0xffffffff,%r13d
je     18f0 <use_free_neuron+0x790>
mov    0x48(%rsp),%rbx
mov    %rbx,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1050 <statm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x60(%rsp)
mov    %rbx,%rdi
mov    %r13d,%esi
mov    $0x1,%al
call   1030 <statds@plt>
xorpd  %xmm2,%xmm2
mov    0x30(%rsp),%r8
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x724(%rip),%xmm0
mulsd  0x60(%rsp),%xmm0
jmp    1940 <use_free_neuron+0x7e0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x80(%rsp),%rax
movsd  (%rax,%r14,8),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    1940 <use_free_neuron+0x7e0>
jp     1940 <use_free_neuron+0x7e0>
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rax,%r14,8)
mov    %r14d,%esi
ucomisd 0x40(%rsp),%xmm0
ja     194c <use_free_neuron+0x7ec>
mov    0x10(%rsp),%r9d
mov    0x20(%rsp),%rdi
mov    0x38(%rsp),%r11
jmp    1977 <use_free_neuron+0x817>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x58(%rsp),%esi
ucomisd 0x40(%rsp),%xmm0
jbe    1923 <use_free_neuron+0x7c3>
mov    0x70(%rsp),%rax
movsd  (%rax,%r14,8),%xmm1
ucomisd %xmm2,%xmm1
mov    0x10(%rsp),%r9d
mov    0x20(%rsp),%rdi
mov    0x38(%rsp),%r11
jne    1977 <use_free_neuron+0x817>
jp     1977 <use_free_neuron+0x817>
movsd  %xmm0,0x40(%rsp)
mov    %r14d,%ebp
add    $0x1,%r14
cmp    0x78(%rsp),%r14
jne    16b2 <use_free_neuron+0x552>
test   %ebp,%ebp
je     1a5e <use_free_neuron+0x8fe>
movslq %ebp,%rax
mov    0x70(%rsp),%rcx
movabs $0x3ff0000000000000,%rdx
mov    %rdx,(%rcx,%rax,8)
test   %esi,%esi
je     1a5e <use_free_neuron+0x8fe>
cmpl   $0x0,0xc(%rsp)
mov    0xa0(%rsp),%rbp
mov    0x68(%rsp),%r10
jle    1690 <use_free_neuron+0x530>
movslq %esi,%rcx
cmpq   $0x3,0x50(%rsp)
jae    19d3 <use_free_neuron+0x873>
xor    %edx,%edx
jmp    1a25 <use_free_neuron+0x8c5>
xor    %edx,%edx
mov    0x90(%rsp),%rbx
nopl   (%rax)
mov    0x0(%rbp,%rdx,8),%rsi
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
mov    0x8(%rbp,%rdx,8),%rsi
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
mov    0x10(%rbp,%rdx,8),%rsi
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
mov    0x18(%rbp,%rdx,8),%rsi
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    19e0 <use_free_neuron+0x880>
test   %r10,%r10
je     1690 <use_free_neuron+0x530>
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%rsi,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x1,%rsi
cmp    %rsi,%r10
jne    1a40 <use_free_neuron+0x8e0>
jmp    1690 <use_free_neuron+0x530>
call   1040 <free@plt>
mov    0x18(%rsp),%rdi
call   1040 <free@plt>
mov    0x48(%rsp),%rdi
call   1040 <free@plt>
mov    0x80(%rsp),%rdi
call   1040 <free@plt>
mov    0x70(%rsp),%rdi
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free@plt>
mov    %ebx,%r15d
and    $0xfffffffc,%r15d
xor    %ebp,%ebp
mov    0x18(%rsp),%rbx
jmp    1abd <use_free_neuron+0x95d>
nop
add    $0x4,%rbp
cmp    %rbp,%r15
je     12c5 <use_free_neuron+0x165>
cmpl   $0x0,0xc(%rsp)
jle    1ab0 <use_free_neuron+0x950>
mov    (%rbx,%rbp,8),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1060 <memset@plt>
mov    0x8(%rbx,%rbp,8),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1060 <memset@plt>
mov    0x10(%rbx,%rbp,8),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1060 <memset@plt>
mov    0x18(%rbx,%rbp,8),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1060 <memset@plt>
mov    0x38(%rsp),%r11
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%r9d
mov    0x30(%rsp),%r8
jmp    1ab0 <use_free_neuron+0x950>

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

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