double *getP5(double *x, double *y, double *z, double *r2, double *alphas,
              double *betas, int Asize, int Nsize, double *ReX) {
  double *P5 = (double *)malloc(Nsize * Nsize * sizeof(double));
  if (Asize == 0) {
    for (int n = 0; n < Nsize * Nsize; n++) {
      P5[n] = 0.0;
    }
    return P5;
  }
  double sumsInner = 0;
  double sumsOuter = 0;
  double oneO1Palpha;
  double oneO1PalphaSqrt;
  double z2 = 0;
  double *alphaO1Palpha = (double *)malloc(Nsize * sizeof(double));
  double *oneO1PalphaSqrt13 = (double *)malloc(Nsize * sizeof(double));
  double *ReXStripe = (double *)malloc(Asize * Asize * sizeof(double));
  double *zr9 = (double *)malloc(Asize * sizeof(double));
  double *zr3 = (double *)malloc(Asize * sizeof(double));
  double *zr21 = (double *)malloc(Asize * sizeof(double));
  double *zr63 = (double *)malloc(Asize * sizeof(double));
  double *kkdij =
      (double *)malloc(Nsize * Nsize * Asize * Asize * sizeof(double));
  for (int n = 0; n < Nsize; n++) {
    oneO1Palpha = 1.0 / (1.00000000 + alphas[5 * Nsize + n]);
    oneO1PalphaSqrt = sqrt(oneO1Palpha);
    oneO1PalphaSqrt13[n] = oneO1PalphaSqrt * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha;
    alphaO1Palpha[n] = alphas[5 * Nsize + n] * oneO1Palpha;
  }
  for (int i = 0; i < Asize; i++) {
    z2 = z[i] * z[i];
    zr9[i] = 9.0 * z2 - r2[i];
    zr3[i] = 3.0 * z2 - r2[i];
    zr21[i] = 21 * z2 * z2 - 14 * z2 * r2[i] + r2[i] * r2[i];
    zr63[i] = 63 * z2 * z2 - 70 * z2 * r2[i] + 15 * r2[i] * r2[i];
  }
  for (int i = 0; i < Asize; i++) {
    for (int j = 0; j < Asize; j++) {
      ReXStripe[i * Asize + j] =
          31.5 * ReX[4 * Asize * Asize + i * Asize + j] +
          z[i] * z[j] *
              (315 * ReX[3 * Asize * Asize + i * Asize + j] +
               420 * zr3[i] * zr3[j] * ReX[Asize * Asize + i * Asize + j] +
               zr63[i] * zr63[j]) +
          17.5 * zr9[i] * zr9[j] * ReX[2 * Asize * Asize + i * Asize + j] +
          15 * zr21[i] * zr21[j] * ReX[i * Asize + j];
    }
  }
  for (int k = 0; k < Nsize; k++) {
    for (int kd = 0; kd < Nsize; kd++) {
      for (int i = 0; i < Asize; i++) {
        for (int j = 0; j < Asize; j++) {
          kkdij[k * Nsize * Asize * Asize + kd * Asize * Asize + i * Asize +
                j] = ReXStripe[i * Asize + j] *
                     exp(-alphaO1Palpha[k] * r2[i] - alphaO1Palpha[kd] * r2[j]);
        }
      }
    }
  }
  for (int n = 0; n < Nsize; n++) {
    for (int nd = n; nd < Nsize; nd++) {
      sumsOuter = 0;
      for (int k = 0; k < Nsize; k++) {
        for (int kd = 0; kd < Nsize; kd++) {
          sumsInner = 0;
          for (int i = 0; i < Asize; i++) {
            for (int j = 0; j < Asize; j++) {
              sumsInner += kkdij[k * Nsize * Asize * Asize +
                                 kd * Asize * Asize + i * Asize + j];
            }
          }
          sumsOuter += betas[5 * Nsize * Nsize + n * Nsize + k] *
                       betas[5 * Nsize * Nsize + nd * Nsize + kd] *
                       oneO1PalphaSqrt13[k] * oneO1PalphaSqrt13[kd] * sumsInner;
        }
      }
      P5[Nsize * n + nd] = 11.0 * 9.86960440108936 * 0.00390625 * sumsOuter;
    }
  }
  for (int n = 0; n < Nsize; n++) {
    for (int nd = n + 1; nd < Nsize; nd++) {
      P5[Nsize * nd + n] = P5[Nsize * n + nd];
    }
  }
  free(oneO1PalphaSqrt13);
  free(alphaO1Palpha);
  free(ReXStripe);
  free(zr9);
  free(zr3);
  free(zr21);
  free(zr63);
  free(kkdij);
  return P5;
}


x86 assembly (clang, -O0):
<getP5>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    0x18(%rbp),%eax
imul   0x18(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
cmpl   $0x0,0x10(%rbp)
jne    11d2 <getP5+0x92>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    11c5 <getP5+0x85>
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1195 <getP5+0x55>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1c89 <getP5+0xb49>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    0x10(%rbp),%eax
imul   0x10(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa8(%rbp)
mov    0x18(%rbp),%eax
imul   0x18(%rbp),%eax
imul   0x10(%rbp),%eax
imul   0x10(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1361 <getP5+0x221>
mov    -0x30(%rbp),%rax
imul   $0x5,0x18(%rbp),%ecx
add    -0xb4(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd96(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  0xd89(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
imul   $0x5,0x18(%rbp),%ecx
add    -0xb4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    12a2 <getP5+0x162>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    156b <getP5+0x42b>
mov    -0x20(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xb8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xc85(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xc2e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xc03(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  0xbe9(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xb6a(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  0xb50(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  0xae1(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    136b <getP5+0x22b>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    17ac <getP5+0x66c>
movl   $0x0,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1793 <getP5+0x653>
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x2,%ecx
imul   0x10(%rbp),%ecx
mov    -0xbc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xc0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
imul   $0x3,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xbc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xc0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x98(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  0xa07(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
mov    -0x98(%rbp),%rax
movslq -0xc0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xbc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xc0(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
movsd  0x9ba(%rip),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0xa8(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xa8(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0x970(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  0x94a(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x90(%rbp),%rax
movslq -0xc0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   0x10(%rbp),%ecx
mov    -0xbc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xc0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xa0(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  0x8e4(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0xc0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0xbc(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xc0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
mov    -0xbc(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xc0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    158e <getP5+0x44e>
jmp    1798 <getP5+0x658>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1575 <getP5+0x435>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1963 <getP5+0x823>
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    194a <getP5+0x80a>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1931 <getP5+0x7f1>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1918 <getP5+0x7d8>
mov    -0x88(%rbp),%rax
mov    -0xcc(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x78(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
mov    -0xc4(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xc8(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0xcc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    1801 <getP5+0x6c1>
jmp    191d <getP5+0x7dd>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    17e8 <getP5+0x6a8>
jmp    1936 <getP5+0x7f6>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    17cf <getP5+0x68f>
jmp    194f <getP5+0x80f>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    17b6 <getP5+0x676>
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1b8b <getP5+0xa4b>
mov    -0xd4(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1b72 <getP5+0xa32>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1b35 <getP5+0x9f5>
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1b1c <getP5+0x9dc>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1a85 <getP5+0x945>
movl   $0x0,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1a6c <getP5+0x92c>
mov    -0xb0(%rbp),%rax
mov    -0xdc(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xe0(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0xe4(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    19fc <getP5+0x8bc>
jmp    1a71 <getP5+0x931>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    19e3 <getP5+0x8a3>
mov    -0x38(%rbp),%rax
imul   $0x5,0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
mov    -0xd4(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0xdc(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
imul   $0x5,0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
mov    -0xd8(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0xe0(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0xdc(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0xe0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    19c2 <getP5+0x882>
jmp    1b21 <getP5+0x9e1>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    19a9 <getP5+0x869>
movsd  0x4c3(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xd4(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1988 <getP5+0x848>
jmp    1b77 <getP5+0xa37>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    196d <getP5+0x82d>
movl   $0x0,-0xec(%rbp)
mov    -0xec(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1c27 <getP5+0xae7>
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1c0e <getP5+0xace>
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xec(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xf0(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf0(%rbp)
jmp    1bb3 <getP5+0xa73>
jmp    1c13 <getP5+0xad3>
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    1b95 <getP5+0xa55>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getP5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r9,0xc0(%rsp)
mov    %r8,%r12
mov    %rcx,0x60(%rsp)
mov    %rdx,0xd8(%rsp)
mov    0x178(%rsp),%r15d
mov    0x170(%rsp),%r14d
mov    %r15d,%r13d
imul   %r13d,%r13d
lea    0x0(,%r13,8),%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x78(%rsp)
test   %r14d,%r14d
je     1370 <getP5+0x220>
mov    %r14d,%ecx
movslq %r15d,%rax
mov    %rax,0x80(%rsp)
mov    %r15,%r14
lea    0x0(,%rax,8),%rbx
mov    %rbx,%rdi
mov    %ecx,%r15d
call   1050 <malloc@plt>
mov    %rax,0xb8(%rsp)
mov    %rbx,0xd0(%rsp)
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    %r15d,%ebx
imul   %ebx,%ebx
lea    0x0(,%rbx,8),%rdi
call   1050 <malloc@plt>
mov    %rax,0xb0(%rsp)
movslq %r15d,%rbp
shl    $0x3,%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %rbp,0x68(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %rbx,0x70(%rsp)
mov    %ebx,%eax
mov    %r13,0xc8(%rsp)
imul   %r13d,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %r14d,%eax
mov    %rax,0x8(%rsp)
test   %r14d,%r14d
mov    0xd8(%rsp),%r14
jle    1333 <getP5+0x1e3>
mov    0x178(%rsp),%eax
lea    (%rax,%rax,4),%eax
cltq
lea    (%r12,%rax,8),%rbx
xor    %ebp,%ebp
movsd  0xd60(%rip),%xmm1
xorpd  %xmm2,%xmm2
jmp    1313 <getP5+0x1c3>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm3,%xmm0
movsd  %xmm3,0x48(%rsp)
call   1070 <sqrt@plt>
movsd  0x48(%rsp),%xmm3
xorpd  %xmm2,%xmm2
movsd  0xd2f(%rip),%xmm1
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mov    0x88(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
mulsd  (%rbx,%rbp,8),%xmm3
mov    0xb8(%rsp),%rax
movsd  %xmm3,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,0x8(%rsp)
je     1333 <getP5+0x1e3>
movsd  (%rbx,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
divsd  %xmm0,%xmm3
ucomisd %xmm2,%xmm3
jb     12b0 <getP5+0x160>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    12d1 <getP5+0x181>
mov    %r13,0x48(%rsp)
mov    0x170(%rsp),%ebx
mov    %ebx,%r13d
test   %ebx,%ebx
mov    %r15,0x50(%rsp)
jle    1a77 <getP5+0x927>
cmp    $0x1,%ebx
jne    138d <getP5+0x23d>
xor    %r8d,%r8d
mov    0x38(%rsp),%rcx
mov    0x30(%rsp),%rdx
mov    0x60(%rsp),%rsi
mov    0x10(%rsp),%rdi
jmp    1492 <getP5+0x342>
test   %r13d,%r13d
je     1f0c <getP5+0xdbc>
mov    0x78(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
jmp    1f0c <getP5+0xdbc>
mov    %r13d,%r8d
and    $0xfffffffe,%r8d
xor    %eax,%eax
movapd 0xcd1(%rip),%xmm8
movapd 0xcd8(%rip),%xmm9
movapd 0xcdf(%rip),%xmm10
movapd 0xce6(%rip),%xmm11
movapd 0xcee(%rip),%xmm4
movapd 0xcf6(%rip),%xmm5
movapd 0xcfe(%rip),%xmm6
mov    0x38(%rsp),%rcx
mov    0x30(%rsp),%rdx
mov    0x60(%rsp),%rsi
mov    0x10(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
movupd (%r14,%rax,8),%xmm1
mulpd  %xmm1,%xmm1
movupd (%rsi,%rax,8),%xmm3
movapd %xmm1,%xmm7
mulpd  %xmm8,%xmm7
subpd  %xmm3,%xmm7
movupd %xmm7,(%rdi,%rax,8)
movapd %xmm1,%xmm7
mulpd  %xmm9,%xmm7
subpd  %xmm3,%xmm7
movupd %xmm7,(%r15,%rax,8)
movapd %xmm1,%xmm7
mulpd  %xmm10,%xmm7
movapd %xmm1,%xmm2
mulpd  %xmm11,%xmm2
mulpd  %xmm3,%xmm2
mulpd  %xmm1,%xmm7
addpd  %xmm2,%xmm7
movapd %xmm1,%xmm2
mulpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm2
mulpd  %xmm5,%xmm1
mulpd  %xmm3,%xmm1
movapd %xmm3,%xmm0
mulpd  %xmm6,%xmm0
mulpd  %xmm3,%xmm0
mulpd  %xmm3,%xmm3
addpd  %xmm7,%xmm3
movupd %xmm3,(%rcx,%rax,8)
addpd  %xmm2,%xmm1
addpd  %xmm1,%xmm0
movupd %xmm0,(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r8
jne    13f0 <getP5+0x2a0>
cmp    %r13,%r8
je     158a <getP5+0x43a>
lea    (%rdx,%r8,8),%r9
lea    (%rcx,%r8,8),%r10
lea    (%r15,%r8,8),%r11
lea    (%rdi,%r8,8),%rdi
lea    (%rsi,%r8,8),%rax
lea    (%r14,%r8,8),%rcx
mov    %r13,%rdx
sub    %r8,%rdx
xor    %esi,%esi
movsd  0xb4d(%rip),%xmm8
movsd  0xb4c(%rip),%xmm9
movsd  0xb4b(%rip),%xmm10
movsd  0xb4a(%rip),%xmm11
movsd  0xb4a(%rip),%xmm4
movsd  0xb4a(%rip),%xmm5
movsd  0xb4a(%rip),%xmm6
xchg   %ax,%ax
movsd  (%rcx,%rsi,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  (%rax,%rsi,8),%xmm3
movapd %xmm1,%xmm7
mulsd  %xmm8,%xmm7
subsd  %xmm3,%xmm7
movsd  %xmm7,(%rdi,%rsi,8)
movapd %xmm1,%xmm7
mulsd  %xmm9,%xmm7
subsd  %xmm3,%xmm7
movsd  %xmm7,(%r11,%rsi,8)
movapd %xmm1,%xmm7
mulsd  %xmm10,%xmm7
movapd %xmm1,%xmm2
mulsd  %xmm11,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm7
addsd  %xmm2,%xmm7
movapd %xmm1,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm5,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm6,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm3
addsd  %xmm7,%xmm3
movsd  %xmm3,(%r10,%rsi,8)
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r9,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    14f0 <getP5+0x3a0>
mov    0x170(%rsp),%ebx
test   %ebx,%ebx
jle    1a77 <getP5+0x927>
mov    0x180(%rsp),%rcx
mov    0x70(%rsp),%rax
lea    0x0(,%rax,4),%edx
lea    (%rax,%rax,2),%esi
lea    (%rax,%rax,1),%edi
lea    -0x1(%r13),%rbp
mov    %rbp,0xf8(%rsp)
mov    %r13d,%ebp
and    $0xfffffffe,%ebp
mov    %rbp,0xe0(%rsp)
mov    %eax,%eax
xor    %ebp,%ebp
movsd  0xa66(%rip),%xmm8
movsd  0xa65(%rip),%xmm9
movsd  0xa4c(%rip),%xmm10
movsd  0xa5b(%rip),%xmm11
movsd  0xa5b(%rip),%xmm0
movapd 0xadb(%rip),%xmm2
movapd 0xae3(%rip),%xmm5
mov    %rdx,0x100(%rsp)
mov    %rsi,0xf0(%rsp)
mov    %rdi,0xe8(%rsp)
mov    %rcx,0x58(%rsp)
mov    0xb0(%rsp),%r12
jmp    168d <getP5+0x53d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x108(%rsp),%rbp
add    $0x1,%rbp
mov    0x68(%rsp),%rax
add    %rax,%r12
add    %rax,0x58(%rsp)
mov    0x20(%rsp),%rdi
add    %r13,%rdi
mov    0x40(%rsp),%rax
add    %r13,%rax
mov    0x28(%rsp),%rsi
add    %r13,%rsi
mov    (%rsp),%rdx
add    %r13,%rdx
cmp    %r13,%rbp
mov    0x50(%rsp),%r15
mov    0x170(%rsp),%ebx
je     1a77 <getP5+0x927>
mov    %rdi,0x20(%rsp)
mov    %rsi,0x28(%rsp)
mov    %rdx,(%rsp)
mov    %rax,0x40(%rsp)
movsd  (%r14,%rbp,8),%xmm12
movsd  (%r15,%rbp,8),%xmm1
mulsd  %xmm8,%xmm1
mov    0x30(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm13
mov    0x10(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm14
mulsd  %xmm9,%xmm14
mov    0x38(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm15
mulsd  %xmm10,%xmm15
cmp    $0x2,%ebx
mov    %rbp,0x108(%rsp)
jae    1700 <getP5+0x5b0>
xor    %edx,%edx
mov    0x180(%rsp),%rbx
jmp    194c <getP5+0x7fc>
nopl   0x0(%rax,%rax,1)
mov    %ebp,%eax
imul   %r13d,%eax
mov    0x100(%rsp),%rcx
add    %eax,%ecx
mov    0xf8(%rsp),%rdi
lea    (%rcx,%rdi,1),%edx
cmp    %ecx,%edx
mov    0x180(%rsp),%rbx
jl     194a <getP5+0x7fa>
mov    %rdi,%rcx
shr    $0x20,%rcx
jne    194a <getP5+0x7fa>
mov    0xf0(%rsp),%rdx
add    %eax,%edx
lea    (%rdx,%rdi,1),%esi
cmp    %edx,%esi
jl     194a <getP5+0x7fa>
test   %rcx,%rcx
jne    194a <getP5+0x7fa>
mov    0x70(%rsp),%rdx
add    %eax,%edx
lea    (%rdx,%rdi,1),%esi
cmp    %edx,%esi
jl     194a <getP5+0x7fa>
test   %rcx,%rcx
jne    194a <getP5+0x7fa>
add    0xe8(%rsp),%eax
lea    (%rax,%rdi,1),%edx
cmp    %eax,%edx
jl     194a <getP5+0x7fa>
mov    $0x0,%edx
test   %rcx,%rcx
jne    194c <getP5+0x7fc>
movapd %xmm12,0x90(%rsp)
unpcklpd %xmm12,%xmm12
movapd %xmm12,0xa0(%rsp)
movapd %xmm1,0x120(%rsp)
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
movapd %xmm13,0x110(%rsp)
movapd %xmm13,%xmm7
unpcklpd %xmm13,%xmm7
movapd %xmm14,%xmm1
unpcklpd %xmm14,%xmm1
movapd %xmm15,%xmm8
unpcklpd %xmm15,%xmm8
xor    %eax,%eax
mov    0x50(%rsp),%r8
mov    0x38(%rsp),%r9
mov    0x30(%rsp),%r10
mov    0xe0(%rsp),%rbp
mov    0x40(%rsp),%r11
mov    (%rsp),%r15
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%rdx
mov    0x58(%rsp),%rsi
mov    %r12,0x18(%rsp)
mov    %r14,%r12
mov    0x10(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r15,%rax,1),%ecx
movslq %ecx,%rcx
movupd (%rbx,%rcx,8),%xmm9
movupd (%r12,%rax,8),%xmm10
mulpd  0xa0(%rsp),%xmm10
lea    (%rdi,%rax,1),%ecx
movslq %ecx,%rcx
movupd (%rbx,%rcx,8),%xmm11
movupd (%r8,%rax,8),%xmm12
mulpd  %xmm0,%xmm12
lea    (%r11,%rax,1),%ecx
movslq %ecx,%rcx
movupd (%rbx,%rcx,8),%xmm13
mulpd  %xmm12,%xmm13
mulpd  %xmm2,%xmm11
addpd  %xmm13,%xmm11
movupd (%r10,%rax,8),%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm11,%xmm3
mulpd  %xmm10,%xmm3
mulpd  %xmm5,%xmm9
addpd  %xmm3,%xmm9
movupd (%r14,%rax,8),%xmm3
mulpd  %xmm1,%xmm3
lea    (%rdx,%rax,1),%ecx
movslq %ecx,%rcx
movupd (%rbx,%rcx,8),%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm9,%xmm4
movupd (%r9,%rax,8),%xmm3
mulpd  %xmm8,%xmm3
movupd (%rsi,%rax,8),%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm4,%xmm6
mov    0x18(%rsp),%rcx
movupd %xmm6,(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1830 <getP5+0x6e0>
mov    %rbp,%rdx
cmp    %r13,%rbp
movsd  0x746(%rip),%xmm8
movsd  0x745(%rip),%xmm9
movsd  0x72c(%rip),%xmm10
movsd  0x73b(%rip),%xmm11
movsd  0x73b(%rip),%xmm0
mov    %r12,%r14
mov    0x18(%rsp),%r12
movapd 0x90(%rsp),%xmm12
movapd 0x120(%rsp),%xmm1
movapd 0x110(%rsp),%xmm13
je     1640 <getP5+0x4f0>
jmp    194c <getP5+0x7fc>
xor    %edx,%edx
mov    0x58(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    %rax,0x18(%rsp)
lea    (%r12,%rdx,8),%rax
mov    %rax,0xa0(%rsp)
mov    0x38(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    %rax,0x90(%rsp)
mov    0x10(%rsp),%rax
lea    (%rax,%rdx,8),%rdi
mov    0x30(%rsp),%rax
lea    (%rax,%rdx,8),%r9
mov    0x50(%rsp),%rax
lea    (%rax,%rdx,8),%r8
lea    (%r14,%rdx,8),%r10
mov    0x20(%rsp),%rax
lea    (%rax,%rdx,1),%r11d
mov    0x40(%rsp),%rax
add    %edx,%eax
mov    0x28(%rsp),%rcx
lea    (%rcx,%rdx,1),%r15d
mov    (%rsp),%rcx
lea    (%rcx,%rdx,1),%esi
mov    %r13,%rcx
sub    %rdx,%rcx
xor    %edx,%edx
xchg   %ax,%ax
movsd  (%r8,%rdx,8),%xmm3
mulsd  %xmm1,%xmm3
lea    (%rax,%rdx,1),%ebp
movslq %ebp,%rbp
mulsd  (%rbx,%rbp,8),%xmm3
lea    (%r15,%rdx,1),%ebp
movslq %ebp,%rbp
movsd  (%rbx,%rbp,8),%xmm4
movsd  (%rdi,%rdx,8),%xmm6
mulsd  %xmm14,%xmm6
lea    (%r11,%rdx,1),%ebp
movslq %ebp,%rbp
mulsd  (%rbx,%rbp,8),%xmm6
lea    (%rsi,%rdx,1),%ebp
movslq %ebp,%rbp
movsd  (%rbx,%rbp,8),%xmm7
mulsd  %xmm11,%xmm4
addsd  %xmm3,%xmm4
movsd  (%r9,%rdx,8),%xmm3
mulsd  %xmm13,%xmm3
addsd  %xmm4,%xmm3
movsd  (%r10,%rdx,8),%xmm4
mulsd  %xmm12,%xmm4
mulsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm7
addsd  %xmm3,%xmm7
addsd  %xmm7,%xmm6
mov    0x90(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm3
mulsd  %xmm15,%xmm3
mov    0x18(%rsp),%rbp
mulsd  0x0(%rbp,%rdx,8),%xmm3
addsd  %xmm6,%xmm3
mov    0xa0(%rsp),%rbp
movsd  %xmm3,0x0(%rbp,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    19c0 <getP5+0x870>
jmp    1640 <getP5+0x4f0>
mov    0x178(%rsp),%eax
test   %eax,%eax
mov    0x10(%rsp),%r14
jle    1eb7 <getP5+0xd67>
imul   0x70(%rsp),%eax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
xor    %ecx,%ecx
mov    %rcx,0x20(%rsp)
mov    0x60(%rsp),%r15
jmp    1ad6 <getP5+0x986>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%rdx
add    $0x1,%rdx
mov    0x58(%rsp),%rax
add    0x40(%rsp),%rax
mov    %rdx,%rcx
mov    %rdx,0x20(%rsp)
cmp    0x8(%rsp),%rdx
je     1bf0 <getP5+0xaa0>
mov    %rax,0x58(%rsp)
mov    %rax,(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
jmp    1b1c <getP5+0x9cc>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
mov    (%rsp),%rax
add    0x70(%rsp),%rax
mov    %rax,(%rsp)
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
cmp    0x8(%rsp),%rcx
mov    0x170(%rsp),%ebx
je     1ab0 <getP5+0x960>
test   %ebx,%ebx
jle    1af0 <getP5+0x9a0>
mov    0xb8(%rsp),%rax
mov    0x20(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movapd 0x5c6(%rip),%xmm0
xorpd  %xmm0,%xmm2
mov    0x28(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorpd  %xmm0,%xmm3
mov    (%rsp),%rbp
mov    0xb0(%rsp),%r14
xor    %ebx,%ebx
movapd %xmm2,0xa0(%rsp)
movapd %xmm3,0x90(%rsp)
nopl   0x0(%rax)
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%r12,8),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  (%r15,%r12,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  (%r15,%rbx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <exp@plt>
movapd 0x90(%rsp),%xmm3
movapd 0xa0(%rsp),%xmm2
mulsd  0x18(%rsp),%xmm0
lea    (%r12,%rbp,1),%eax
cltq
mov    0x48(%rsp),%rsi
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%r12
cmp    %r12,%r13
jne    1b80 <getP5+0xa30>
add    $0x1,%rbx
add    0x68(%rsp),%r14
add    %r13,%rbp
cmp    %r13,%rbx
jne    1b70 <getP5+0xa20>
jmp    1af0 <getP5+0x9a0>
mov    0x178(%rsp),%eax
test   %eax,%eax
mov    0x10(%rsp),%r14
mov    0x50(%rsp),%r15
jle    1eb7 <getP5+0xd67>
mov    0xc8(%rsp),%rax
lea    (%rax,%rax,4),%eax
cltq
mov    %rax,0x68(%rsp)
lea    -0x1(%r13),%rcx
mov    %r13d,%edx
and    $0x3,%edx
mov    %r13d,%esi
and    $0xfffffffc,%esi
mov    0x48(%rsp),%rax
lea    0x18(%rax),%rdi
xor    %r9d,%r9d
movsd  0x421(%rip),%xmm0
jmp    1c63 <getP5+0xb13>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%r9
add    $0x1,%r9
cmp    0x8(%rsp),%r9
je     1e23 <getP5+0xcd3>
mov    %r9,%r8
imul   0x80(%rsp),%r8
mov    0x68(%rsp),%rax
mov    %r8,%rbp
mov    %r8,0x60(%rsp)
add    %r8,%rax
mov    %rax,0xa0(%rsp)
mov    %r9,(%rsp)
mov    %r9,%r12
jmp    1cba <getP5+0xb6a>
mulsd  %xmm0,%xmm1
mov    0x60(%rsp),%rax
mov    0x90(%rsp),%r12
add    %r12,%rax
mov    0x78(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%r12
cmp    0x8(%rsp),%r12
je     1c50 <getP5+0xb00>
mov    %r12,0x90(%rsp)
imul   0x80(%rsp),%r12
add    0x68(%rsp),%r12
xorpd  %xmm1,%xmm1
xor    %r8d,%r8d
xor    %r9d,%r9d
jmp    1cf5 <getP5+0xba5>
nopl   0x0(%rax)
add    $0x1,%r9
mov    0x18(%rsp),%r8
add    0x40(%rsp),%r8d
cmp    0x8(%rsp),%r9
je     1c90 <getP5+0xb40>
mov    0xa0(%rsp),%rax
add    %r9,%rax
mov    0xc0(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm2
mov    0x88(%rsp),%rax
movsd  (%rax,%r9,8),%xmm3
mov    %r8,0x18(%rsp)
mov    %r8d,%r14d
xor    %r11d,%r11d
jmp    1d74 <getP5+0xc24>
nopl   0x0(%rax)
lea    (%r12,%r11,1),%rax
mov    0xc0(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm5
mov    0x88(%rsp),%rax
mulsd  (%rax,%r11,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm5,%xmm1
add    $0x1,%r11
add    0x70(%rsp),%r14d
cmp    0x8(%rsp),%r11
je     1ce0 <getP5+0xb90>
xorpd  %xmm4,%xmm4
test   %ebx,%ebx
jle    1d30 <getP5+0xbe0>
mov    %r14d,%r10d
xor    %r15d,%r15d
jmp    1da3 <getP5+0xc53>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r15
mov    0x170(%rsp),%ebx
add    %ebx,%r10d
cmp    %r13,%r15
je     1d30 <getP5+0xbe0>
movslq %r10d,%rbp
cmp    $0x3,%rcx
jae    1dc0 <getP5+0xc70>
xor    %r8d,%r8d
jmp    1df4 <getP5+0xca4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rbp,8),%rax
xor    %r8d,%r8d
nopw   0x0(%rax,%rax,1)
addsd  -0x18(%rax,%r8,8),%xmm4
addsd  -0x10(%rax,%r8,8),%xmm4
addsd  -0x8(%rax,%r8,8),%xmm4
addsd  (%rax,%r8,8),%xmm4
add    $0x4,%r8
cmp    %r8,%rsi
jne    1dd0 <getP5+0xc80>
test   %rdx,%rdx
je     1d90 <getP5+0xc40>
add    %rbp,%r8
mov    0x48(%rsp),%rax
lea    (%rax,%r8,8),%rax
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
addsd  (%rax,%rbp,8),%xmm4
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1e10 <getP5+0xcc0>
jmp    1d90 <getP5+0xc40>
mov    0x178(%rsp),%eax
test   %eax,%eax
mov    0xd0(%rsp),%rcx
mov    0x10(%rsp),%r14
mov    0x50(%rsp),%r15
jle    1eb7 <getP5+0xd67>
mov    0x78(%rsp),%rdi
mov    0x80(%rsp),%rax
lea    (%rdi,%rax,8),%rbx
lea    0x8(,%rax,8),%r8
xor    %edx,%edx
mov    0x8(%rsp),%rsi
jmp    1e81 <getP5+0xd31>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %r8,%rbx
add    %r8,%rdi
add    $0xffffffffffffffff,%rsi
cmp    0x8(%rsp),%rdx
je     1eb7 <getP5+0xd67>
add    $0x1,%rdx
cmp    0x80(%rsp),%rdx
jge    1e70 <getP5+0xd20>
mov    $0x1,%ebp
mov    %rbx,%rax
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rbp,8),%xmm0
movsd  %xmm0,(%rax)
add    %rcx,%rax
add    $0x1,%rbp
cmp    %rbp,%rsi
jne    1ea0 <getP5+0xd50>
jmp    1e70 <getP5+0xd20>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
mov    0xb8(%rsp),%rdi
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double* @getP5(double* %0, double* %1, double* %2, double* %3, double* %4, double* %5, i32 %6, i32 %7, double* %8) {
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32
%19 = alloca double*
%20 = alloca double*
%21 = alloca i32
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca double*
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
store double* %0, double** %11
store double* %1, double** %12
store double* %2, double** %13
store double* %3, double** %14
store double* %4, double** %15
store double* %5, double** %16
store i32 %6, i32* %17
store i32 %7, i32* %18
store double* %8, double** %19
%51 = load i32, i32* %18
%52 = load i32, i32* %18
%53 = mul nsw i32 %51, %52
%54 = sext i32 %53 to i64
%55 = mul i64 %54, 8
%56 = call i8* @malloc(i64 %55)
%57 = bitcast i8* %56 to double*
store double* %57, double** %20
%58 = load i32, i32* %17
%59 = icmp eq i32 %58, 0
br i1 %59, label %60, label %77
60: ; preds = %9
store i32 0, i32* %21
br label %61
61: ; preds = %72, %60
%62 = load i32, i32* %21
%63 = load i32, i32* %18
%64 = load i32, i32* %18
%65 = mul nsw i32 %63, %64
%66 = icmp slt i32 %62, %65
br i1 %66, label %67, label %75
67: ; preds = %61
%68 = load double*, double** %20
%69 = load i32, i32* %21
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds double, double* %68, i64 %70
store double 0.000000e+00, double* %71
br label %72
72: ; preds = %67
%73 = load i32, i32* %21
%74 = add nsw i32 %73, 1
store i32 %74, i32* %21
br label %61
75: ; preds = %61
%76 = load double*, double** %20
store double* %76, double** %10
br label %714
77: ; preds = %9
store double 0.000000e+00, double* %22
store double 0.000000e+00, double* %23
store double 0.000000e+00, double* %26
%78 = load i32, i32* %18
%79 = sext i32 %78 to i64
%80 = mul i64 %79, 8
%81 = call i8* @malloc(i64 %80)
%82 = bitcast i8* %81 to double*
store double* %82, double** %27
%83 = load i32, i32* %18
%84 = sext i32 %83 to i64
%85 = mul i64 %84, 8
%86 = call i8* @malloc(i64 %85)
%87 = bitcast i8* %86 to double*
store double* %87, double** %28
%88 = load i32, i32* %17
%89 = load i32, i32* %17
%90 = mul nsw i32 %88, %89
%91 = sext i32 %90 to i64
%92 = mul i64 %91, 8
%93 = call i8* @malloc(i64 %92)
%94 = bitcast i8* %93 to double*
store double* %94, double** %29
%95 = load i32, i32* %17
%96 = sext i32 %95 to i64
%97 = mul i64 %96, 8
%98 = call i8* @malloc(i64 %97)
%99 = bitcast i8* %98 to double*
store double* %99, double** %30
%100 = load i32, i32* %17
%101 = sext i32 %100 to i64
%102 = mul i64 %101, 8
%103 = call i8* @malloc(i64 %102)
%104 = bitcast i8* %103 to double*
store double* %104, double** %31
%105 = load i32, i32* %17
%106 = sext i32 %105 to i64
%107 = mul i64 %106, 8
%108 = call i8* @malloc(i64 %107)
%109 = bitcast i8* %108 to double*
store double* %109, double** %32
%110 = load i32, i32* %17
%111 = sext i32 %110 to i64
%112 = mul i64 %111, 8
%113 = call i8* @malloc(i64 %112)
%114 = bitcast i8* %113 to double*
store double* %114, double** %33
%115 = load i32, i32* %18
%116 = load i32, i32* %18
%117 = mul nsw i32 %115, %116
%118 = load i32, i32* %17
%119 = mul nsw i32 %117, %118
%120 = load i32, i32* %17
%121 = mul nsw i32 %119, %120
%122 = sext i32 %121 to i64
%123 = mul i64 %122, 8
%124 = call i8* @malloc(i64 %123)
%125 = bitcast i8* %124 to double*
store double* %125, double** %34
store i32 0, i32* %35
br label %126
126: ; preds = %174, %77
%127 = load i32, i32* %35
%128 = load i32, i32* %18
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %177
130: ; preds = %126
%131 = load double*, double** %15
%132 = load i32, i32* %18
%133 = mul nsw i32 5, %132
%134 = load i32, i32* %35
%135 = add nsw i32 %133, %134
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %131, i64 %136
%138 = load double, double* %137
%139 = fadd double 1.000000e+00, %138
%140 = fdiv double 1.000000e+00, %139
store double %140, double* %24
%141 = load double, double* %24
%142 = call double @sqrt(double %141)
store double %142, double* %25
%143 = load double, double* %25
%144 = load double, double* %24
%145 = fmul double %143, %144
%146 = load double, double* %24
%147 = fmul double %145, %146
%148 = load double, double* %24
%149 = fmul double %147, %148
%150 = load double, double* %24
%151 = fmul double %149, %150
%152 = load double, double* %24
%153 = fmul double %151, %152
%154 = load double, double* %24
%155 = fmul double %153, %154
%156 = load double*, double** %28
%157 = load i32, i32* %35
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %156, i64 %158
store double %155, double* %159
%160 = load double*, double** %15
%161 = load i32, i32* %18
%162 = mul nsw i32 5, %161
%163 = load i32, i32* %35
%164 = add nsw i32 %162, %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %160, i64 %165
%167 = load double, double* %166
%168 = load double, double* %24
%169 = fmul double %167, %168
%170 = load double*, double** %27
%171 = load i32, i32* %35
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double, double* %170, i64 %172
store double %169, double* %173
br label %174
174: ; preds = %130
%175 = load i32, i32* %35
%176 = add nsw i32 %175, 1
store i32 %176, i32* %35
br label %126
177: ; preds = %126
store i32 0, i32* %36
br label %178
178: ; preds = %275, %177
%179 = load i32, i32* %36
%180 = load i32, i32* %17
%181 = icmp slt i32 %179, %180
br i1 %181, label %182, label %278
182: ; preds = %178
%183 = load double*, double** %13
%184 = load i32, i32* %36
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %183, i64 %185
%187 = load double, double* %186
%188 = load double*, double** %13
%189 = load i32, i32* %36
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %188, i64 %190
%192 = load double, double* %191
%193 = fmul double %187, %192
store double %193, double* %26
%194 = load double, double* %26
%195 = load double*, double** %14
%196 = load i32, i32* %36
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double, double* %195, i64 %197
%199 = load double, double* %198
%200 = fneg double %199
%201 = call double @llvm.fmuladd.f64(double 9.000000e+00, double %194, double %200)
%202 = load double*, double** %30
%203 = load i32, i32* %36
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds double, double* %202, i64 %204
store double %201, double* %205
%206 = load double, double* %26
%207 = load double*, double** %14
%208 = load i32, i32* %36
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds double, double* %207, i64 %209
%211 = load double, double* %210
%212 = fneg double %211
%213 = call double @llvm.fmuladd.f64(double 3.000000e+00, double %206, double %212)
%214 = load double*, double** %31
%215 = load i32, i32* %36
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds double, double* %214, i64 %216
store double %213, double* %217
%218 = load double, double* %26
%219 = fmul double 2.100000e+01, %218
%220 = load double, double* %26
%221 = load double, double* %26
%222 = fmul double 1.400000e+01, %221
%223 = load double*, double** %14
%224 = load i32, i32* %36
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %223, i64 %225
%227 = load double, double* %226
%228 = fmul double %222, %227
%229 = fneg double %228
%230 = call double @llvm.fmuladd.f64(double %219, double %220, double %229)
%231 = load double*, double** %14
%232 = load i32, i32* %36
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds double, double* %231, i64 %233
%235 = load double, double* %234
%236 = load double*, double** %14
%237 = load i32, i32* %36
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %236, i64 %238
%240 = load double, double* %239
%241 = call double @llvm.fmuladd.f64(double %235, double %240, double %230)
%242 = load double*, double** %32
%243 = load i32, i32* %36
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds double, double* %242, i64 %244
store double %241, double* %245
%246 = load double, double* %26
%247 = fmul double 6.300000e+01, %246
%248 = load double, double* %26
%249 = load double, double* %26
%250 = fmul double 7.000000e+01, %249
%251 = load double*, double** %14
%252 = load i32, i32* %36
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double, double* %251, i64 %253
%255 = load double, double* %254
%256 = fmul double %250, %255
%257 = fneg double %256
%258 = call double @llvm.fmuladd.f64(double %247, double %248, double %257)
%259 = load double*, double** %14
%260 = load i32, i32* %36
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double, double* %259, i64 %261
%263 = load double, double* %262
%264 = fmul double 1.500000e+01, %263
%265 = load double*, double** %14
%266 = load i32, i32* %36
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %265, i64 %267
%269 = load double, double* %268
%270 = call double @llvm.fmuladd.f64(double %264, double %269, double %258)
%271 = load double*, double** %33
%272 = load i32, i32* %36
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds double, double* %271, i64 %273
store double %270, double* %274
br label %275
275: ; preds = %182
%276 = load i32, i32* %36
%277 = add nsw i32 %276, 1
store i32 %277, i32* %36
br label %178
278: ; preds = %178
store i32 0, i32* %37
br label %279
279: ; preds = %429, %278
%280 = load i32, i32* %37
%281 = load i32, i32* %17
%282 = icmp slt i32 %280, %281
br i1 %282, label %283, label %432
283: ; preds = %279
store i32 0, i32* %38
br label %284
284: ; preds = %425, %283
%285 = load i32, i32* %38
%286 = load i32, i32* %17
%287 = icmp slt i32 %285, %286
br i1 %287, label %288, label %428
288: ; preds = %284
%289 = load double*, double** %19
%290 = load i32, i32* %17
%291 = mul nsw i32 4, %290
%292 = load i32, i32* %17
%293 = mul nsw i32 %291, %292
%294 = load i32, i32* %37
%295 = load i32, i32* %17
%296 = mul nsw i32 %294, %295
%297 = add nsw i32 %293, %296
%298 = load i32, i32* %38
%299 = add nsw i32 %297, %298
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double, double* %289, i64 %300
%302 = load double, double* %301
%303 = load double*, double** %13
%304 = load i32, i32* %37
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds double, double* %303, i64 %305
%307 = load double, double* %306
%308 = load double*, double** %13
%309 = load i32, i32* %38
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds double, double* %308, i64 %310
%312 = load double, double* %311
%313 = fmul double %307, %312
%314 = load double*, double** %19
%315 = load i32, i32* %17
%316 = mul nsw i32 3, %315
%317 = load i32, i32* %17
%318 = mul nsw i32 %316, %317
%319 = load i32, i32* %37
%320 = load i32, i32* %17
%321 = mul nsw i32 %319, %320
%322 = add nsw i32 %318, %321
%323 = load i32, i32* %38
%324 = add nsw i32 %322, %323
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %314, i64 %325
%327 = load double, double* %326
%328 = load double*, double** %31
%329 = load i32, i32* %37
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %328, i64 %330
%332 = load double, double* %331
%333 = fmul double 4.200000e+02, %332
%334 = load double*, double** %31
%335 = load i32, i32* %38
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds double, double* %334, i64 %336
%338 = load double, double* %337
%339 = fmul double %333, %338
%340 = load double*, double** %19
%341 = load i32, i32* %17
%342 = load i32, i32* %17
%343 = mul nsw i32 %341, %342
%344 = load i32, i32* %37
%345 = load i32, i32* %17
%346 = mul nsw i32 %344, %345
%347 = add nsw i32 %343, %346
%348 = load i32, i32* %38
%349 = add nsw i32 %347, %348
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds double, double* %340, i64 %350
%352 = load double, double* %351
%353 = fmul double %339, %352
%354 = call double @llvm.fmuladd.f64(double 3.150000e+02, double %327, double %353)
%355 = load double*, double** %33
%356 = load i32, i32* %37
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds double, double* %355, i64 %357
%359 = load double, double* %358
%360 = load double*, double** %33
%361 = load i32, i32* %38
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds double, double* %360, i64 %362
%364 = load double, double* %363
%365 = call double @llvm.fmuladd.f64(double %359, double %364, double %354)
%366 = fmul double %313, %365
%367 = call double @llvm.fmuladd.f64(double 3.150000e+01, double %302, double %366)
%368 = load double*, double** %30
%369 = load i32, i32* %37
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds double, double* %368, i64 %370
%372 = load double, double* %371
%373 = fmul double 1.750000e+01, %372
%374 = load double*, double** %30
%375 = load i32, i32* %38
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds double, double* %374, i64 %376
%378 = load double, double* %377
%379 = fmul double %373, %378
%380 = load double*, double** %19
%381 = load i32, i32* %17
%382 = mul nsw i32 2, %381
%383 = load i32, i32* %17
%384 = mul nsw i32 %382, %383
%385 = load i32, i32* %37
%386 = load i32, i32* %17
%387 = mul nsw i32 %385, %386
%388 = add nsw i32 %384, %387
%389 = load i32, i32* %38
%390 = add nsw i32 %388, %389
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds double, double* %380, i64 %391
%393 = load double, double* %392
%394 = call double @llvm.fmuladd.f64(double %379, double %393, double %367)
%395 = load double*, double** %32
%396 = load i32, i32* %37
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds double, double* %395, i64 %397
%399 = load double, double* %398
%400 = fmul double 1.500000e+01, %399
%401 = load double*, double** %32
%402 = load i32, i32* %38
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double, double* %401, i64 %403
%405 = load double, double* %404
%406 = fmul double %400, %405
%407 = load double*, double** %19
%408 = load i32, i32* %37
%409 = load i32, i32* %17
%410 = mul nsw i32 %408, %409
%411 = load i32, i32* %38
%412 = add nsw i32 %410, %411
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds double, double* %407, i64 %413
%415 = load double, double* %414
%416 = call double @llvm.fmuladd.f64(double %406, double %415, double %394)
%417 = load double*, double** %29
%418 = load i32, i32* %37
%419 = load i32, i32* %17
%420 = mul nsw i32 %418, %419
%421 = load i32, i32* %38
%422 = add nsw i32 %420, %421
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %417, i64 %423
store double %416, double* %424
br label %425
425: ; preds = %288
%426 = load i32, i32* %38
%427 = add nsw i32 %426, 1
store i32 %427, i32* %38
br label %284
428: ; preds = %284
br label %429
429: ; preds = %428
%430 = load i32, i32* %37
%431 = add nsw i32 %430, 1
store i32 %431, i32* %37
br label %279
432: ; preds = %279
store i32 0, i32* %39
br label %433
433: ; preds = %522, %432
%434 = load i32, i32* %39
%435 = load i32, i32* %18
%436 = icmp slt i32 %434, %435
br i1 %436, label %437, label %525
437: ; preds = %433
store i32 0, i32* %40
br label %438
438: ; preds = %518, %437
%439 = load i32, i32* %40
%440 = load i32, i32* %18
%441 = icmp slt i32 %439, %440
br i1 %441, label %442, label %521
442: ; preds = %438
store i32 0, i32* %41
br label %443
443: ; preds = %514, %442
%444 = load i32, i32* %41
%445 = load i32, i32* %17
%446 = icmp slt i32 %444, %445
br i1 %446, label %447, label %517
447: ; preds = %443
store i32 0, i32* %42
br label %448
448: ; preds = %510, %447
%449 = load i32, i32* %42
%450 = load i32, i32* %17
%451 = icmp slt i32 %449, %450
br i1 %451, label %452, label %513
452: ; preds = %448
%453 = load double*, double** %29
%454 = load i32, i32* %41
%455 = load i32, i32* %17
%456 = mul nsw i32 %454, %455
%457 = load i32, i32* %42
%458 = add nsw i32 %456, %457
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds double, double* %453, i64 %459
%461 = load double, double* %460
%462 = load double*, double** %27
%463 = load i32, i32* %39
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds double, double* %462, i64 %464
%466 = load double, double* %465
%467 = fneg double %466
%468 = load double*, double** %14
%469 = load i32, i32* %41
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds double, double* %468, i64 %470
%472 = load double, double* %471
%473 = load double*, double** %27
%474 = load i32, i32* %40
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds double, double* %473, i64 %475
%477 = load double, double* %476
%478 = load double*, double** %14
%479 = load i32, i32* %42
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds double, double* %478, i64 %480
%482 = load double, double* %481
%483 = fmul double %477, %482
%484 = fneg double %483
%485 = call double @llvm.fmuladd.f64(double %467, double %472, double %484)
%486 = call double @exp(double %485)
%487 = fmul double %461, %486
%488 = load double*, double** %34
%489 = load i32, i32* %39
%490 = load i32, i32* %18
%491 = mul nsw i32 %489, %490
%492 = load i32, i32* %17
%493 = mul nsw i32 %491, %492
%494 = load i32, i32* %17
%495 = mul nsw i32 %493, %494
%496 = load i32, i32* %40
%497 = load i32, i32* %17
%498 = mul nsw i32 %496, %497
%499 = load i32, i32* %17
%500 = mul nsw i32 %498, %499
%501 = add nsw i32 %495, %500
%502 = load i32, i32* %41
%503 = load i32, i32* %17
%504 = mul nsw i32 %502, %503
%505 = add nsw i32 %501, %504
%506 = load i32, i32* %42
%507 = add nsw i32 %505, %506
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds double, double* %488, i64 %508
store double %487, double* %509
br label %510
510: ; preds = %452
%511 = load i32, i32* %42
%512 = add nsw i32 %511, 1
store i32 %512, i32* %42
br label %448
513: ; preds = %448
br label %514
514: ; preds = %513
%515 = load i32, i32* %41
%516 = add nsw i32 %515, 1
store i32 %516, i32* %41
br label %443
517: ; preds = %443
br label %518
518: ; preds = %517
%519 = load i32, i32* %40
%520 = add nsw i32 %519, 1
store i32 %520, i32* %40
br label %438
521: ; preds = %438
br label %522
522: ; preds = %521
%523 = load i32, i32* %39
%524 = add nsw i32 %523, 1
store i32 %524, i32* %39
br label %433
525: ; preds = %433
store i32 0, i32* %43
br label %526
526: ; preds = %656, %525
%527 = load i32, i32* %43
%528 = load i32, i32* %18
%529 = icmp slt i32 %527, %528
br i1 %529, label %530, label %659
530: ; preds = %526
%531 = load i32, i32* %43
store i32 %531, i32* %44
br label %532
532: ; preds = %652, %530
%533 = load i32, i32* %44
%534 = load i32, i32* %18
%535 = icmp slt i32 %533, %534
br i1 %535, label %536, label %655
536: ; preds = %532
store double 0.000000e+00, double* %23
store i32 0, i32* %45
br label %537
537: ; preds = %638, %536
%538 = load i32, i32* %45
%539 = load i32, i32* %18
%540 = icmp slt i32 %538, %539
br i1 %540, label %541, label %641
541: ; preds = %537
store i32 0, i32* %46
br label %542
542: ; preds = %634, %541
%543 = load i32, i32* %46
%544 = load i32, i32* %18
%545 = icmp slt i32 %543, %544
br i1 %545, label %546, label %637
546: ; preds = %542
store double 0.000000e+00, double* %22
store i32 0, i32* %47
br label %547
547: ; preds = %586, %546
%548 = load i32, i32* %47
%549 = load i32, i32* %17
%550 = icmp slt i32 %548, %549
br i1 %550, label %551, label %589
551: ; preds = %547
store i32 0, i32* %48
br label %552
552: ; preds = %582, %551
%553 = load i32, i32* %48
%554 = load i32, i32* %17
%555 = icmp slt i32 %553, %554
br i1 %555, label %556, label %585
556: ; preds = %552
%557 = load double*, double** %34
%558 = load i32, i32* %45
%559 = load i32, i32* %18
%560 = mul nsw i32 %558, %559
%561 = load i32, i32* %17
%562 = mul nsw i32 %560, %561
%563 = load i32, i32* %17
%564 = mul nsw i32 %562, %563
%565 = load i32, i32* %46
%566 = load i32, i32* %17
%567 = mul nsw i32 %565, %566
%568 = load i32, i32* %17
%569 = mul nsw i32 %567, %568
%570 = add nsw i32 %564, %569
%571 = load i32, i32* %47
%572 = load i32, i32* %17
%573 = mul nsw i32 %571, %572
%574 = add nsw i32 %570, %573
%575 = load i32, i32* %48
%576 = add nsw i32 %574, %575
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds double, double* %557, i64 %577
%579 = load double, double* %578
%580 = load double, double* %22
%581 = fadd double %580, %579
store double %581, double* %22
br label %582
582: ; preds = %556
%583 = load i32, i32* %48
%584 = add nsw i32 %583, 1
store i32 %584, i32* %48
br label %552
585: ; preds = %552
br label %586
586: ; preds = %585
%587 = load i32, i32* %47
%588 = add nsw i32 %587, 1
store i32 %588, i32* %47
br label %547
589: ; preds = %547
%590 = load double*, double** %16
%591 = load i32, i32* %18
%592 = mul nsw i32 5, %591
%593 = load i32, i32* %18
%594 = mul nsw i32 %592, %593
%595 = load i32, i32* %43
%596 = load i32, i32* %18
%597 = mul nsw i32 %595, %596
%598 = add nsw i32 %594, %597
%599 = load i32, i32* %45
%600 = add nsw i32 %598, %599
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds double, double* %590, i64 %601
%603 = load double, double* %602
%604 = load double*, double** %16
%605 = load i32, i32* %18
%606 = mul nsw i32 5, %605
%607 = load i32, i32* %18
%608 = mul nsw i32 %606, %607
%609 = load i32, i32* %44
%610 = load i32, i32* %18
%611 = mul nsw i32 %609, %610
%612 = add nsw i32 %608, %611
%613 = load i32, i32* %46
%614 = add nsw i32 %612, %613
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds double, double* %604, i64 %615
%617 = load double, double* %616
%618 = fmul double %603, %617
%619 = load double*, double** %28
%620 = load i32, i32* %45
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds double, double* %619, i64 %621
%623 = load double, double* %622
%624 = fmul double %618, %623
%625 = load double*, double** %28
%626 = load i32, i32* %46
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds double, double* %625, i64 %627
%629 = load double, double* %628
%630 = fmul double %624, %629
%631 = load double, double* %22
%632 = load double, double* %23
%633 = call double @llvm.fmuladd.f64(double %630, double %631, double %632)
store double %633, double* %23
br label %634
634: ; preds = %589
%635 = load i32, i32* %46
%636 = add nsw i32 %635, 1
store i32 %636, i32* %46
br label %542
637: ; preds = %542
br label %638
638: ; preds = %637
%639 = load i32, i32* %45
%640 = add nsw i32 %639, 1
store i32 %640, i32* %45
br label %537
641: ; preds = %537
%642 = load double, double* %23
%643 = fmul double 0x3FDB24339565A013, %642
%644 = load double*, double** %20
%645 = load i32, i32* %18
%646 = load i32, i32* %43
%647 = mul nsw i32 %645, %646
%648 = load i32, i32* %44
%649 = add nsw i32 %647, %648
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds double, double* %644, i64 %650
store double %643, double* %651
br label %652
652: ; preds = %641
%653 = load i32, i32* %44
%654 = add nsw i32 %653, 1
store i32 %654, i32* %44
br label %532
655: ; preds = %532
br label %656
656: ; preds = %655
%657 = load i32, i32* %43
%658 = add nsw i32 %657, 1
store i32 %658, i32* %43
br label %526
659: ; preds = %526
store i32 0, i32* %49
br label %660
660: ; preds = %693, %659
%661 = load i32, i32* %49
%662 = load i32, i32* %18
%663 = icmp slt i32 %661, %662
br i1 %663, label %664, label %696
664: ; preds = %660
%665 = load i32, i32* %49
%666 = add nsw i32 %665, 1
store i32 %666, i32* %50
br label %667
667: ; preds = %689, %664
%668 = load i32, i32* %50
%669 = load i32, i32* %18
%670 = icmp slt i32 %668, %669
br i1 %670, label %671, label %692
671: ; preds = %667
%672 = load double*, double** %20
%673 = load i32, i32* %18
%674 = load i32, i32* %49
%675 = mul nsw i32 %673, %674
%676 = load i32, i32* %50
%677 = add nsw i32 %675, %676
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds double, double* %672, i64 %678
%680 = load double, double* %679
%681 = load double*, double** %20
%682 = load i32, i32* %18
%683 = load i32, i32* %50
%684 = mul nsw i32 %682, %683
%685 = load i32, i32* %49
%686 = add nsw i32 %684, %685
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds double, double* %681, i64 %687
store double %680, double* %688
br label %689
689: ; preds = %671
%690 = load i32, i32* %50
%691 = add nsw i32 %690, 1
store i32 %691, i32* %50
br label %667
692: ; preds = %667
br label %693
693: ; preds = %692
%694 = load i32, i32* %49
%695 = add nsw i32 %694, 1
store i32 %695, i32* %49
br label %660
696: ; preds = %660
%697 = load double*, double** %28
%698 = bitcast double* %697 to i8*
%699 = load double*, double** %27
%700 = bitcast double* %699 to i8*
%701 = load double*, double** %29
%702 = bitcast double* %701 to i8*
%703 = load double*, double** %30
%704 = bitcast double* %703 to i8*
%705 = load double*, double** %31
%706 = bitcast double* %705 to i8*
%707 = load double*, double** %32
%708 = bitcast double* %707 to i8*
%709 = load double*, double** %33
%710 = bitcast double* %709 to i8*
%711 = load double*, double** %34
%712 = bitcast double* %711 to i8*
%713 = load double*, double** %20
store double* %713, double** %10
br label %714
714: ; preds = %696, %75
%715 = load double*, double** %10
ret double* %715
}

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