double *getP8(double *x, double *y, double *z, double *r2, double *alphas,
              double *betas, int Asize, int Nsize, double *ReX) {
  double *P8 = (double *)malloc(Nsize * Nsize * sizeof(double));
  if (Asize == 0) {
    for (int n = 0; n < Nsize * Nsize; n++) {
      P8[n] = 0.0;
    }
    return P8;
  }
  double sumsInner = 0;
  double sumsOuter = 0;
  double oneO1Palpha;
  double oneO1PalphaSqrt;
  double z2 = 0, z4 = 0, z6 = 0, z8 = 0;
  double r4 = 0, r6 = 0, r8 = 0;
  double *alphaO1Palpha = (double *)malloc(Nsize * sizeof(double));
  double *oneO1PalphaSqrt19 = (double *)malloc(Nsize * sizeof(double));
  double *ReXStripe = (double *)malloc(Asize * Asize * sizeof(double));
  double *zr15 = (double *)malloc(Asize * sizeof(double));
  double *zr5 = (double *)malloc(Asize * sizeof(double));
  double *zr65 = (double *)malloc(Asize * sizeof(double));
  double *zr39 = (double *)malloc(Asize * sizeof(double));
  double *zr143 = (double *)malloc(Asize * sizeof(double));
  double *zr715 = (double *)malloc(Asize * sizeof(double));
  double *zr6435 = (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.0 + alphas[8 * Nsize + n]);
    oneO1PalphaSqrt = sqrt(oneO1Palpha);
    oneO1PalphaSqrt19[n] = oneO1PalphaSqrt * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha;
    alphaO1Palpha[n] = alphas[8 * Nsize + n] * oneO1Palpha;
  }
  for (int i = 0; i < Asize; i++) {
    z2 = z[i] * z[i];
    z4 = z2 * z2;
    z6 = z2 * z4;
    z8 = z4 * z4;
    r4 = r2[i] * r2[i];
    r6 = r4 * r2[i];
    r8 = r4 * r4;
    zr5[i] = 5.0 * z2 - r2[i];
    zr15[i] = 15.0 * z2 - r2[i];
    zr65[i] = 65 * z4 - 26 * z2 * r2[i] + r4;
    zr39[i] = 39 * z4 - 26 * z2 * r2[i] + 3 * r4;
    zr143[i] = 143 * z6 - 143 * z4 * r2[i] + 33 * z2 * r4 - r6;
    zr715[i] = 715 * z6 - 1001 * z4 * r2[i] + 385 * z2 * r4 - 35 * r6;
    zr6435[i] = 6435 * z8 - 12012 * z6 * r2[i] + 6930 * z4 * r4 -
                1260 * z2 * r6 + 35 * r8;
  }
  for (int i = 0; i < Asize; i++) {
    for (int j = 0; j < Asize; j++) {
      ReXStripe[i * Asize + j] =
          z[i] * z[j] *
              (102960 * ReX[6 * Asize * Asize + i * Asize + j] +
               144144 * zr5[i] * zr5[j] *
                   ReX[4 * Asize * Asize + i * Asize + j] +
               18480 * zr39[i] * zr39[j] *
                   ReX[2 * Asize * Asize + i * Asize + j] +
               144 * zr715[i] * zr715[j] * ReX[i * Asize + j]) +
          6435 * ReX[7 * Asize * Asize + i * Asize + j] +
          3432 * zr15[i] * zr15[j] * ReX[5 * Asize * Asize + i * Asize + j] +
          2772 * zr65[i] * zr65[j] * ReX[3 * Asize * Asize + i * Asize + j] +
          2520 * zr143[i] * zr143[j] * ReX[Asize * Asize + i * Asize + j] +
          zr6435[i] * zr6435[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[8 * Nsize * Nsize + n * Nsize + k] *
                       betas[8 * Nsize * Nsize + nd * Nsize + kd] *
                       oneO1PalphaSqrt19[k] * oneO1PalphaSqrt19[kd] * sumsInner;
        }
      }
      P8[Nsize * n + nd] =
          17.0 * 9.86960440108936 * 1.52587890625e-05 * sumsOuter;
    }
  }
  for (int n = 0; n < Nsize; n++) {
    for (int nd = n + 1; nd < Nsize; nd++) {
      P8[Nsize * nd + n] = P8[Nsize * n + nd];
    }
  }
  free(oneO1PalphaSqrt19);
  free(alphaO1Palpha);
  free(ReXStripe);
  free(zr15);
  free(zr5);
  free(zr65);
  free(zr39);
  free(zr143);
  free(zr715);
  free(zr6435);
  free(kkdij);
  return P8;
}


x86 assembly (clang, -O0):
<getP8>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%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 <getP8+0x92>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    11c5 <getP8+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 <getP8+0x55>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    2092 <getP8+0xf52>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xb0(%rbp)
mov    0x10(%rbp),%eax
imul   0x10(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xd0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xd8(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xe0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xe8(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xf0(%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,-0xf8(%rbp)
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    13f8 <getP8+0x2b8>
mov    -0x30(%rbp),%rax
mov    0x18(%rbp),%ecx
shl    $0x3,%ecx
add    -0xfc(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1d7e(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  0x1d71(%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
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0xfc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    0x18(%rbp),%ecx
shl    $0x3,%ecx
add    -0xfc(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0xfc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    1320 <getP8+0x1e0>
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    182a <getP8+0x6ea>
mov    -0x20(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x100(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x100(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x100(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x1bc6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x1b6f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movsd  0x1b37(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x100(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x1b0b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x90(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm1
movsd  0x1ad3(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x100(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1a97(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  0x1a77(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm1
movsd  0x1a47(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x100(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1a13(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x19fb(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x98(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
movsd  0x19b6(%rip),%xmm1
mulsd  -0x78(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x100(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x197a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1962(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x1935(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm1
ff
movsd  0x1902(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x100(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x188e(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x18b6(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1891(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm2
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x184d(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    1402 <getP8+0x2c2>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1b7b <getP8+0xa3b>
movl   $0x0,-0x108(%rbp)
mov    -0x108(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1b62 <getP8+0xa22>
mov    -0x20(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
imul   $0x6,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x104(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x108(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xc8(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  0x1788(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0xc8(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x2,%ecx
imul   0x10(%rbp),%ecx
mov    -0x104(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x108(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1738(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0xd8(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  0x1712(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   0x10(%rbp),%ecx
mov    -0x104(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x108(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0xe8(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  0x16ac(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
mov    -0xe8(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x104(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x108(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x20(%rbp),%rax
imul   $0x7,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x104(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x108(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x163f(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  0x1614(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
imul   $0x5,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x104(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x108(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xd0(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  0x15b0(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
imul   $0x3,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x104(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x108(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  0x154c(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0xe0(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x104(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x108(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
mov    -0x104(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x108(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x108(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x108(%rbp)
jmp    184d <getP8+0x70d>
jmp    1b67 <getP8+0xa27>
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    1834 <getP8+0x6f4>
movl   $0x0,-0x10c(%rbp)
mov    -0x10c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1d38 <getP8+0xbf8>
movl   $0x0,-0x110(%rbp)
mov    -0x110(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1d1f <getP8+0xbdf>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1d06 <getP8+0xbc6>
movl   $0x0,-0x118(%rbp)
mov    -0x118(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1ced <getP8+0xbad>
mov    -0xb8(%rbp),%rax
mov    -0x114(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x118(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0xa8(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xa8(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x118(%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  -0x140(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0xf8(%rbp),%rax
mov    -0x10c(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x110(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x114(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x118(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    1bd0 <getP8+0xa90>
jmp    1cf2 <getP8+0xbb2>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    1bb7 <getP8+0xa77>
jmp    1d0b <getP8+0xbcb>
mov    -0x110(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x110(%rbp)
jmp    1b9e <getP8+0xa5e>
jmp    1d24 <getP8+0xbe4>
mov    -0x10c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10c(%rbp)
jmp    1b85 <getP8+0xa45>
movl   $0x0,-0x11c(%rbp)
mov    -0x11c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1f6a <getP8+0xe2a>
mov    -0x11c(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x120(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1f51 <getP8+0xe11>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x124(%rbp)
mov    -0x124(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1f14 <getP8+0xdd4>
movl   $0x0,-0x128(%rbp)
mov    -0x128(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1efb <getP8+0xdbb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1e5a <getP8+0xd1a>
movl   $0x0,-0x130(%rbp)
mov    -0x130(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1e41 <getP8+0xd01>
mov    -0xf8(%rbp),%rax
mov    -0x124(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x128(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x12c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x130(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x130(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x130(%rbp)
jmp    1dd1 <getP8+0xc91>
jmp    1e46 <getP8+0xd06>
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    1db8 <getP8+0xc78>
mov    -0x38(%rbp),%rax
mov    0x18(%rbp),%ecx
shl    $0x3,%ecx
imul   0x18(%rbp),%ecx
mov    -0x11c(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0x124(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    0x18(%rbp),%ecx
shl    $0x3,%ecx
imul   0x18(%rbp),%ecx
mov    -0x120(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0x128(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x124(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x128(%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    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    1d97 <getP8+0xc57>
jmp    1f00 <getP8+0xdc0>
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    1d7e <getP8+0xc3e>
movsd  0x10e4(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x11c(%rbp),%ecx
add    -0x120(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    1d5d <getP8+0xc1d>
jmp    1f56 <getP8+0xe16>
mov    -0x11c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11c(%rbp)
jmp    1d42 <getP8+0xc02>
movl   $0x0,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    2006 <getP8+0xec6>
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
mov    -0x138(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1fed <getP8+0xead>
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x134(%rbp),%ecx
add    -0x138(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x138(%rbp),%ecx
add    -0x134(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    1f92 <getP8+0xe52>
jmp    1ff2 <getP8+0xeb2>
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1f74 <getP8+0xe34>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getP8>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1f8,%rsp
mov    %r9,0x178(%rsp)
mov    %r8,%r12
mov    %rcx,0x38(%rsp)
mov    %rdx,0x10(%rsp)
mov    0x238(%rsp),%r14d
mov    0x230(%rsp),%r15d
mov    %r14d,%ebx
imul   %ebx,%ebx
lea    0x0(,%rbx,8),%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x88(%rsp)
test   %r15d,%r15d
je     139c <getP8+0x24c>
mov    %r12,0x60(%rsp)
movslq %r14d,%rax
mov    %rax,0x90(%rsp)
lea    0x0(,%rax,8),%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x128(%rsp)
mov    %rbp,0x198(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x98(%rsp)
mov    %r15d,%r13d
imul   %r13d,%r13d
lea    0x0(,%r13,8),%rdi
call   1050 <malloc@plt>
mov    %rax,0x120(%rsp)
movslq %r15d,%rbp
shl    $0x3,%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x80(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %rbp,0x40(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %r13,0x48(%rsp)
mov    %r13d,%eax
mov    %rbx,0x190(%rsp)
imul   %ebx,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %r14d,%eax
mov    %rax,(%rsp)
test   %r14d,%r14d
mov    0x10(%rsp),%rcx
jle    136b <getP8+0x21b>
lea    0x0(,%r14,8),%eax
cltq
mov    0x60(%rsp),%rdx
lea    (%rdx,%rax,8),%r13
xor    %ebp,%ebp
movsd  0x1d3b(%rip),%xmm1
xorpd  %xmm2,%xmm2
jmp    1345 <getP8+0x1f5>
xchg   %ax,%ax
movapd %xmm3,%xmm0
movsd  %xmm3,0x60(%rsp)
call   1070 <sqrt@plt>
movsd  0x60(%rsp),%xmm3
xorpd  %xmm2,%xmm2
movsd  0x1d0f(%rip),%xmm1
mov    0x10(%rsp),%rcx
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mov    0x98(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
mulsd  0x0(%r13,%rbp,8),%xmm3
mov    0x128(%rsp),%rax
movsd  %xmm3,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,(%rsp)
je     136b <getP8+0x21b>
movsd  0x0(%r13,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
divsd  %xmm0,%xmm3
ucomisd %xmm2,%xmm3
jb     12d0 <getP8+0x180>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    12f6 <getP8+0x1a6>
mov    0x230(%rsp),%ebx
mov    %ebx,%r13d
test   %ebx,%ebx
mov    0x80(%rsp),%r14
mov    %r12,0x78(%rsp)
jle    1fcd <getP8+0xe7d>
cmp    $0x1,%ebx
jne    13bb <getP8+0x26b>
xor    %r10d,%r10d
mov    0x38(%rsp),%r8
jmp    15cb <getP8+0x47b>
test   %ebx,%ebx
je     24bd <getP8+0x136d>
mov    0x88(%rsp),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
jmp    24bd <getP8+0x136d>
mov    %r13d,%r10d
and    $0xfffffffe,%r10d
xor    %eax,%eax
movapd 0x1dd4(%rip),%xmm4
movapd 0x1ddc(%rip),%xmm5
movapd 0x1de4(%rip),%xmm6
movapd 0x1dec(%rip),%xmm7
movapd 0x1df3(%rip),%xmm8
movapd 0x1dfa(%rip),%xmm9
mov    0x30(%rsp),%rbx
mov    0x28(%rsp),%rdx
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rdi
mov    0x38(%rsp),%r8
mov    0x8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rcx,%rax,8),%xmm10
mulpd  %xmm10,%xmm10
movapd %xmm10,%xmm11
mulpd  %xmm10,%xmm11
movupd (%r8,%rax,8),%xmm15
movapd %xmm10,%xmm0
mulpd  0x1c98(%rip),%xmm0
subpd  %xmm15,%xmm0
movupd %xmm0,(%r14,%rax,8)
movapd %xmm10,%xmm13
mulpd  0x1c8f(%rip),%xmm13
subpd  %xmm15,%xmm13
movapd %xmm10,%xmm14
mulpd  0x1c8c(%rip),%xmm14
mulpd  %xmm15,%xmm14
movapd %xmm11,%xmm0
mulpd  0x1cba(%rip),%xmm0
mulpd  %xmm15,%xmm0
movapd %xmm11,%xmm1
mulpd  0x1cd8(%rip),%xmm1
mulpd  %xmm15,%xmm1
movapd %xmm15,%xmm12
mulpd  %xmm15,%xmm12
movupd %xmm13,(%r12,%rax,8)
movapd %xmm11,%xmm2
mulpd  0x1c56(%rip),%xmm2
addpd  %xmm14,%xmm2
addpd  %xmm12,%xmm2
movupd %xmm2,0x0(%rbp,%rax,8)
movapd %xmm11,%xmm2
mulpd  0x1c49(%rip),%xmm2
addpd  %xmm14,%xmm2
movapd %xmm12,%xmm3
mulpd  0x1c47(%rip),%xmm3
addpd  %xmm2,%xmm3
movapd %xmm10,%xmm2
mulpd  %xmm11,%xmm2
movupd %xmm3,(%rbx,%rax,8)
movapd %xmm2,%xmm3
mulpd  0x1c48(%rip),%xmm3
addpd  %xmm0,%xmm3
movapd %xmm10,%xmm0
mulpd  0x1c47(%rip),%xmm0
mulpd  %xmm12,%xmm0
addpd  %xmm3,%xmm0
movapd %xmm2,%xmm3
mulpd  %xmm5,%xmm2
mulpd  %xmm15,%xmm2
mulpd  %xmm12,%xmm15
subpd  %xmm15,%xmm0
movupd %xmm0,(%rdx,%rax,8)
mulpd  0x1c3a(%rip),%xmm3
addpd  %xmm1,%xmm3
movapd %xmm10,%xmm0
mulpd  0x1c39(%rip),%xmm0
mulpd  %xmm12,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm8,%xmm10
mulpd  %xmm15,%xmm10
mulpd  %xmm4,%xmm15
addpd  %xmm0,%xmm15
movupd %xmm15,(%rsi,%rax,8)
movapd %xmm11,%xmm0
mulpd  %xmm11,%xmm0
mulpd  %xmm6,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm7,%xmm11
mulpd  %xmm12,%xmm11
addpd  %xmm0,%xmm11
addpd  %xmm11,%xmm10
mulpd  %xmm12,%xmm12
mulpd  %xmm9,%xmm12
addpd  %xmm10,%xmm12
movupd %xmm12,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1420 <getP8+0x2d0>
cmp    %r13,%r10
je     1805 <getP8+0x6b5>
mov    0x18(%rsp),%rax
lea    (%rax,%r10,8),%rbx
mov    0x20(%rsp),%rax
lea    (%rax,%r10,8),%r9
mov    0x28(%rsp),%rax
lea    (%rax,%r10,8),%r11
mov    0x30(%rsp),%rax
lea    (%rax,%r10,8),%rdi
mov    0x8(%rsp),%rax
lea    (%rax,%r10,8),%rax
lea    (%r12,%r10,8),%rcx
lea    (%r14,%r10,8),%rdx
lea    (%r8,%r10,8),%rsi
mov    0x10(%rsp),%rbp
lea    0x0(,%r10,8),%r8
add    %rbp,%r8
mov    %r9,%rbp
mov    %r13,%r9
sub    %r10,%r9
xor    %r10d,%r10d
movsd  0x1a40(%rip),%xmm4
movsd  0x1a40(%rip),%xmm5
movsd  0x1a40(%rip),%xmm6
movsd  0x1a40(%rip),%xmm7
movsd  0x1a3f(%rip),%xmm8
movsd  0x1a3e(%rip),%xmm9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r8,%r10,8),%xmm10
mulsd  %xmm10,%xmm10
movapd %xmm10,%xmm11
mulsd  %xmm10,%xmm11
movsd  (%rsi,%r10,8),%xmm15
movapd %xmm10,%xmm0
mulsd  0x1980(%rip),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,(%rdx,%r10,8)
movapd %xmm10,%xmm13
mulsd  0x196f(%rip),%xmm13
subsd  %xmm15,%xmm13
movapd %xmm10,%xmm14
mulsd  0x1964(%rip),%xmm14
mulsd  %xmm15,%xmm14
movapd %xmm11,%xmm0
mulsd  0x1972(%rip),%xmm0
mulsd  %xmm15,%xmm0
movapd %xmm11,%xmm1
mulsd  0x1978(%rip),%xmm1
mulsd  %xmm15,%xmm1
movapd %xmm15,%xmm12
mulsd  %xmm15,%xmm12
movsd  %xmm13,(%rcx,%r10,8)
movapd %xmm11,%xmm2
mulsd  0x1926(%rip),%xmm2
addsd  %xmm14,%xmm2
addsd  %xmm12,%xmm2
movsd  %xmm2,(%rax,%r10,8)
movapd %xmm11,%xmm2
mulsd  0x1911(%rip),%xmm2
addsd  %xmm14,%xmm2
movapd %xmm12,%xmm3
mulsd  0x1907(%rip),%xmm3
addsd  %xmm2,%xmm3
movapd %xmm10,%xmm2
mulsd  %xmm11,%xmm2
movsd  %xmm3,(%rdi,%r10,8)
movapd %xmm2,%xmm3
mulsd  0x18f7(%rip),%xmm3
addsd  %xmm0,%xmm3
movapd %xmm10,%xmm0
mulsd  0x18ee(%rip),%xmm0
mulsd  %xmm12,%xmm0
addsd  %xmm3,%xmm0
movapd %xmm2,%xmm3
mulsd  %xmm5,%xmm2
mulsd  %xmm15,%xmm2
mulsd  %xmm12,%xmm15
subsd  %xmm15,%xmm0
movsd  %xmm0,(%r11,%r10,8)
mulsd  0x18d0(%rip),%xmm3
addsd  %xmm1,%xmm3
movapd %xmm10,%xmm0
mulsd  0x18c7(%rip),%xmm0
mulsd  %xmm12,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm8,%xmm10
mulsd  %xmm15,%xmm10
mulsd  %xmm4,%xmm15
addsd  %xmm0,%xmm15
movsd  %xmm15,0x0(%rbp,%r10,8)
movapd %xmm11,%xmm0
mulsd  %xmm11,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm7,%xmm11
mulsd  %xmm12,%xmm11
addsd  %xmm0,%xmm11
addsd  %xmm11,%xmm10
mulsd  %xmm12,%xmm12
mulsd  %xmm9,%xmm12
addsd  %xmm10,%xmm12
movsd  %xmm12,(%rbx,%r10,8)
add    $0x1,%r10
cmp    %r10,%r9
jne    1660 <getP8+0x510>
mov    0x230(%rsp),%ebx
test   %ebx,%ebx
mov    0x10(%rsp),%rdx
jle    1fcd <getP8+0xe7d>
mov    0x240(%rsp),%rax
mov    0x48(%rsp),%rcx
lea    (%rcx,%rcx,1),%r10d
lea    (%r10,%r10,2),%r8d
lea    0x0(,%rcx,4),%r9d
lea    0x0(,%rcx,8),%esi
sub    %ecx,%esi
lea    (%rcx,%rcx,4),%r11d
lea    (%rcx,%rcx,2),%ebp
lea    -0x1(%r13),%rdi
mov    %rdi,0x1d0(%rsp)
mov    %r13d,%edi
and    $0xfffffffe,%edi
mov    %rdi,0x1a0(%rsp)
mov    %ecx,%ecx
xor    %edi,%edi
movsd  0x1833(%rip),%xmm11
movsd  0x1832(%rip),%xmm12
movsd  0x1849(%rip),%xmm10
mov    %r8,0x1d8(%rsp)
mov    %r9,0x1c8(%rsp)
mov    %r10,0x1c0(%rsp)
mov    %rsi,0x1b8(%rsp)
mov    %r11,0x1b0(%rsp)
mov    %rbp,0x1a8(%rsp)
mov    %rbp,0xe8(%rsp)
mov    %rax,0xe0(%rsp)
mov    0x120(%rsp),%rbp
mov    %rbp,0xd8(%rsp)
mov    0x8(%rsp),%rbp
jmp    1965 <getP8+0x815>
nopl   0x0(%rax)
mov    0x1e0(%rsp),%rdi
add    $0x1,%rdi
mov    0x40(%rsp),%rcx
add    %rcx,0xd8(%rsp)
add    %rcx,0xe0(%rsp)
mov    0x118(%rsp),%rcx
add    %r13,%rcx
add    %r13,0xe8(%rsp)
mov    0xf0(%rsp),%r11
add    %r13,%r11
mov    0xf8(%rsp),%rsi
add    %r13,%rsi
mov    0x100(%rsp),%r10
add    %r13,%r10
mov    0x108(%rsp),%r9
add    %r13,%r9
mov    0x110(%rsp),%r8
add    %r13,%r8
cmp    %r13,%rdi
mov    0x8(%rsp),%rbp
mov    0x230(%rsp),%ebx
mov    0x10(%rsp),%rdx
je     1fcd <getP8+0xe7d>
mov    %rsi,0xf8(%rsp)
mov    %rcx,0x118(%rsp)
movsd  (%rdx,%rdi,8),%xmm0
movsd  (%r14,%rdi,8),%xmm14
mulsd  0x170f(%rip),%xmm14
mov    0x30(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm15
mulsd  %xmm11,%xmm15
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm13
mulsd  %xmm12,%xmm13
movsd  (%r12,%rdi,8),%xmm9
mulsd  0x16f8(%rip),%xmm9
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  0x16f2(%rip),%xmm1
mov    0x28(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm8
mulsd  0x16e6(%rip),%xmm8
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm2
cmp    $0x2,%ebx
movapd %xmm0,0x60(%rsp)
movapd %xmm2,0x160(%rsp)
mov    %rdi,0x1e0(%rsp)
mov    %r8,0x110(%rsp)
mov    %r9,0x108(%rsp)
mov    %r10,0x100(%rsp)
mov    %r11,0xf0(%rsp)
jae    1c60 <getP8+0xb10>
xor    %ecx,%ecx
mov    0xe0(%rsp),%rdx
lea    (%rdx,%rcx,8),%rbp
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    %rdx,0xc0(%rsp)
mov    0x18(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    %rdx,0x140(%rsp)
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    %rdx,0x130(%rsp)
mov    0x8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    %rdx,0x50(%rsp)
lea    (%r12,%rcx,8),%rdx
mov    %rdx,0xb0(%rsp)
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    %rdx,0xa0(%rsp)
mov    0x30(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    %rdx,0x150(%rsp)
lea    (%r14,%rcx,8),%rdx
mov    %rdx,0x180(%rsp)
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    %rdx,0x1f0(%rsp)
mov    0x118(%rsp),%rdx
add    %ecx,%edx
mov    %rdx,0x1e8(%rsp)
mov    0xe8(%rsp),%rdx
lea    (%rdx,%rcx,1),%esi
mov    0xf0(%rsp),%rdx
add    %ecx,%edx
mov    %r13,%r9
sub    %rcx,%r9
mov    0xf8(%rsp),%rdi
lea    (%rdi,%rcx,1),%r11d
mov    0x100(%rsp),%rdi
lea    (%rdi,%rcx,1),%r8d
mov    0x108(%rsp),%rdi
lea    (%rdi,%rcx,1),%r10d
mov    0x110(%rsp),%rdi
add    %edi,%ecx
xor    %edi,%edi
xchg   %ax,%ax
mov    0x180(%rsp),%rbx
movsd  (%rbx,%rdi,8),%xmm6
mulsd  %xmm14,%xmm6
lea    (%r10,%rdi,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm6
mov    0x150(%rsp),%rbx
movsd  (%rbx,%rdi,8),%xmm7
mulsd  %xmm15,%xmm7
lea    (%r8,%rdi,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm7
lea    (%rcx,%rdi,1),%ebx
movslq %ebx,%rbx
movsd  (%rax,%rbx,8),%xmm2
lea    (%r11,%rdi,1),%ebx
movslq %ebx,%rbx
movsd  (%rax,%rbx,8),%xmm3
mov    0xb0(%rsp),%rbx
movsd  (%rbx,%rdi,8),%xmm4
mulsd  %xmm9,%xmm4
lea    (%rdx,%rdi,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm4
mov    0x50(%rsp),%rbx
movsd  (%rbx,%rdi,8),%xmm5
mulsd  %xmm1,%xmm5
lea    (%rsi,%rdi,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm5
mov    0x130(%rsp),%rbx
movsd  (%rbx,%rdi,8),%xmm0
mulsd  %xmm8,%xmm0
mov    0x1e8(%rsp),%rbx
lea    (%rbx,%rdi,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm0
mulsd  %xmm10,%xmm2
addsd  %xmm6,%xmm2
mov    0xa0(%rsp),%rbx
movsd  (%rbx,%rdi,8),%xmm6
mulsd  %xmm13,%xmm6
mulsd  0x0(%rbp,%rdi,8),%xmm6
addsd  %xmm2,%xmm7
addsd  %xmm7,%xmm6
mov    0x1f0(%rsp),%rbx
movsd  (%rbx,%rdi,8),%xmm2
mulsd  0x60(%rsp),%xmm2
mulsd  %xmm2,%xmm6
mulsd  0x1462(%rip),%xmm3
addsd  %xmm6,%xmm3
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm5
addsd  %xmm5,%xmm0
mov    0x140(%rsp),%rbx
movsd  (%rbx,%rdi,8),%xmm2
mulsd  0x160(%rsp),%xmm2
addsd  %xmm0,%xmm2
mov    0xc0(%rsp),%rbx
movsd  %xmm2,(%rbx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r9
jne    1b20 <getP8+0x9d0>
jmp    18e0 <getP8+0x790>
nop
mov    %edi,%ecx
imul   %r13d,%ecx
mov    0x1d8(%rsp),%rdx
add    %ecx,%edx
mov    0x1d0(%rsp),%rbx
lea    (%rdx,%rbx,1),%esi
cmp    %edx,%esi
jl     1a24 <getP8+0x8d4>
mov    %rbx,%rdx
shr    $0x20,%rdx
jne    1a24 <getP8+0x8d4>
mov    0x1c8(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%rbx,1),%edi
cmp    %esi,%edi
jl     1a24 <getP8+0x8d4>
test   %rdx,%rdx
jne    1a24 <getP8+0x8d4>
mov    0x1c0(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%rbx,1),%edi
cmp    %esi,%edi
jl     1a24 <getP8+0x8d4>
test   %rdx,%rdx
jne    1a24 <getP8+0x8d4>
mov    0x1b8(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%rbx,1),%edi
cmp    %esi,%edi
jl     1a24 <getP8+0x8d4>
test   %rdx,%rdx
jne    1a24 <getP8+0x8d4>
mov    0x1b0(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%rbx,1),%edi
cmp    %esi,%edi
jl     1a24 <getP8+0x8d4>
test   %rdx,%rdx
jne    1a24 <getP8+0x8d4>
mov    0x1a8(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%rbx,1),%edi
cmp    %esi,%edi
jl     1a24 <getP8+0x8d4>
test   %rdx,%rdx
jne    1a24 <getP8+0x8d4>
add    0x48(%rsp),%ecx
lea    (%rcx,%rbx,1),%esi
cmp    %ecx,%esi
jl     1fbd <getP8+0xe6d>
mov    $0x0,%ecx
test   %rdx,%rdx
movsd  0x1382(%rip),%xmm10
jne    1a26 <getP8+0x8d6>
unpcklpd %xmm0,%xmm0
movapd %xmm0,0xc0(%rsp)
movapd %xmm14,%xmm0
unpcklpd %xmm14,%xmm0
movapd %xmm0,0x140(%rsp)
movapd %xmm15,%xmm0
unpcklpd %xmm15,%xmm0
movapd %xmm0,0x130(%rsp)
movapd %xmm13,%xmm0
unpcklpd %xmm13,%xmm0
movapd %xmm0,0x50(%rsp)
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
movapd %xmm0,0xb0(%rsp)
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
movapd %xmm0,0xa0(%rsp)
movapd %xmm8,%xmm0
unpcklpd %xmm8,%xmm0
movapd %xmm0,0x150(%rsp)
unpcklpd %xmm2,%xmm2
movapd %xmm2,0x180(%rsp)
xor    %ecx,%ecx
mov    0x1a0(%rsp),%rbx
mov    0x118(%rsp),%r10
movapd 0x13d3(%rip),%xmm0
mov    0x110(%rsp),%r12
mov    0x108(%rsp),%r14
mov    0x100(%rsp),%r8
mov    0xf8(%rsp),%r9
mov    0xf0(%rsp),%r11
mov    0xe8(%rsp),%rbp
mov    0xe0(%rsp),%rsi
mov    0xd8(%rsp),%rdi
nopl   (%rax)
lea    (%r12,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm10
lea    (%r14,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm11
lea    (%r8,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm12
lea    (%r9,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm2
lea    (%r11,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm3
lea    0x0(%rbp,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm4
lea    (%r10,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm6
mov    0x80(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm7
mulpd  0x140(%rsp),%xmm7
mulpd  %xmm7,%xmm11
mulpd  0x1355(%rip),%xmm10
addpd  %xmm11,%xmm10
mov    0x30(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm7
mulpd  0x130(%rsp),%xmm7
mulpd  %xmm7,%xmm12
addpd  %xmm10,%xmm12
mov    0x20(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm7
mulpd  0x50(%rsp),%xmm7
movupd (%rsi,%rcx,8),%xmm5
mulpd  %xmm7,%xmm5
addpd  %xmm12,%xmm5
mov    0x10(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm7
mulpd  0xc0(%rsp),%xmm7
mulpd  %xmm7,%xmm5
mulpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
mov    0x78(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm5
mulpd  0xb0(%rsp),%xmm5
mulpd  %xmm5,%xmm3
addpd  %xmm2,%xmm3
mov    0x8(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm2
mulpd  0xa0(%rsp),%xmm2
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
mov    0x28(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm2
mulpd  0x150(%rsp),%xmm2
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
mov    0x18(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm2
mulpd  0x180(%rsp),%xmm2
addpd  %xmm6,%xmm2
movupd %xmm2,(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1e30 <getP8+0xce0>
mov    %rbx,%rcx
cmp    %r13,%rbx
movsd  0x110d(%rip),%xmm11
movsd  0x110c(%rip),%xmm12
movsd  0x1123(%rip),%xmm10
mov    0x78(%rsp),%r12
mov    0x80(%rsp),%r14
je     18e0 <getP8+0x790>
jmp    1a26 <getP8+0x8d6>
xor    %ecx,%ecx
movsd  0x1100(%rip),%xmm10
jmp    1a26 <getP8+0x8d6>
mov    0x238(%rsp),%eax
test   %eax,%eax
jle    2447 <getP8+0x12f7>
mov    %r15,0x140(%rsp)
imul   0x48(%rsp),%eax
mov    %rax,0x130(%rsp)
xor    %eax,%eax
xor    %ecx,%ecx
mov    %rcx,0xa0(%rsp)
mov    0x38(%rsp),%r15
jmp    2041 <getP8+0xef1>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xa0(%rsp),%rdx
add    $0x1,%rdx
mov    0x150(%rsp),%rax
add    0x130(%rsp),%rax
mov    %rdx,%rcx
mov    %rdx,0xa0(%rsp)
cmp    (%rsp),%rdx
je     2183 <getP8+0x1033>
mov    %rax,0x150(%rsp)
mov    %rax,0x50(%rsp)
xor    %eax,%eax
mov    %rax,0xb0(%rsp)
jmp    2097 <getP8+0xf47>
nopw   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rcx
add    $0x1,%rcx
mov    0x50(%rsp),%rax
add    0x48(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    %rcx,%rax
mov    %rcx,0xb0(%rsp)
cmp    (%rsp),%rcx
mov    0x230(%rsp),%ebx
je     2010 <getP8+0xec0>
test   %ebx,%ebx
jle    2060 <getP8+0xf10>
mov    0x128(%rsp),%rax
mov    0xa0(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movapd 0x1158(%rip),%xmm0
xorpd  %xmm0,%xmm2
mov    0xb0(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorpd  %xmm0,%xmm3
mov    0x50(%rsp),%rbx
mov    0x120(%rsp),%r14
xor    %edx,%edx
movapd %xmm2,0x160(%rsp)
movapd %xmm3,0xc0(%rsp)
xchg   %ax,%ax
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%r12,8),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  (%r15,%r12,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  (%r15,%rdx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    %r13,%rbp
mov    %rdx,%r13
call   1060 <exp@plt>
mov    %r13,%rdx
mov    %rbp,%r13
movapd 0xc0(%rsp),%xmm3
movapd 0x160(%rsp),%xmm2
mulsd  0x60(%rsp),%xmm0
lea    (%rbx,%r12,1),%eax
cltq
mov    0x140(%rsp),%rsi
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%r12
cmp    %r12,%rbp
jne    2100 <getP8+0xfb0>
add    $0x1,%rdx
add    0x40(%rsp),%r14
add    %r13,%rbx
cmp    %r13,%rdx
jne    20f0 <getP8+0xfa0>
jmp    2060 <getP8+0xf10>
mov    0x238(%rsp),%eax
test   %eax,%eax
mov    0x78(%rsp),%r12
mov    0x140(%rsp),%r15
jle    2447 <getP8+0x12f7>
mov    0x190(%rsp),%rax
shl    $0x3,%eax
cltq
mov    %rax,0x40(%rsp)
lea    -0x1(%r13),%rcx
mov    %r13d,%edx
and    $0x3,%edx
mov    %r13d,%esi
and    $0xfffffffc,%esi
lea    0x18(%r15),%rdi
xor    %r9d,%r9d
movsd  0xf00(%rip),%xmm0
jmp    21f3 <getP8+0x10a3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x50(%rsp),%r9
add    $0x1,%r9
cmp    (%rsp),%r9
je     23c3 <getP8+0x1273>
mov    %r9,%r8
imul   0x90(%rsp),%r8
mov    0x40(%rsp),%rax
mov    %r8,%rbp
mov    %r8,0x38(%rsp)
add    %r8,%rax
mov    %rax,0x160(%rsp)
mov    %r9,0x50(%rsp)
mov    %r9,%r12
jmp    225c <getP8+0x110c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
mov    0x38(%rsp),%rax
mov    0xc0(%rsp),%r12
add    %r12,%rax
mov    0x88(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%r12
cmp    (%rsp),%r12
je     21e0 <getP8+0x1090>
mov    %r12,0xc0(%rsp)
imul   0x90(%rsp),%r12
add    0x40(%rsp),%r12
xorpd  %xmm1,%xmm1
xor    %r8d,%r8d
xor    %r9d,%r9d
jmp    2297 <getP8+0x1147>
xchg   %ax,%ax
add    $0x1,%r9
mov    0x60(%rsp),%r8
add    0x130(%rsp),%r8d
cmp    (%rsp),%r9
je     2230 <getP8+0x10e0>
mov    0x160(%rsp),%rax
add    %r9,%rax
mov    0x178(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm2
mov    0x98(%rsp),%rax
movsd  (%rax,%r9,8),%xmm3
mov    %r8,0x60(%rsp)
mov    %r8d,%r14d
xor    %r11d,%r11d
jmp    2313 <getP8+0x11c3>
nopl   0x0(%rax,%rax,1)
lea    (%r12,%r11,1),%rax
mov    0x178(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm5
mov    0x98(%rsp),%rax
mulsd  (%rax,%r11,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm5,%xmm1
add    $0x1,%r11
add    0x48(%rsp),%r14d
cmp    (%rsp),%r11
je     2280 <getP8+0x1130>
xorpd  %xmm4,%xmm4
test   %ebx,%ebx
jle    22d0 <getP8+0x1180>
mov    %r14d,%r10d
xor    %ebp,%ebp
jmp    2343 <getP8+0x11f3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
mov    0x230(%rsp),%ebx
add    %ebx,%r10d
cmp    %r13,%rbp
je     22d0 <getP8+0x1180>
movslq %r10d,%rbx
cmp    $0x3,%rcx
jae    2360 <getP8+0x1210>
xor    %r8d,%r8d
jmp    2394 <getP8+0x1244>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rbx,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    2370 <getP8+0x1220>
test   %rdx,%rdx
je     2330 <getP8+0x11e0>
add    %rbx,%r8
lea    (%r15,%r8,8),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  (%rax,%rbx,8),%xmm4
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    23b0 <getP8+0x1260>
jmp    2330 <getP8+0x11e0>
mov    0x238(%rsp),%eax
test   %eax,%eax
mov    0x198(%rsp),%rcx
mov    0x78(%rsp),%r12
jle    2447 <getP8+0x12f7>
mov    0x88(%rsp),%rdi
mov    0x90(%rsp),%rax
lea    (%rdi,%rax,8),%rbx
lea    0x8(,%rax,8),%r8
xor    %edx,%edx
mov    (%rsp),%rsi
jmp    2410 <getP8+0x12c0>
nop
add    %r8,%rbx
add    %r8,%rdi
add    $0xffffffffffffffff,%rsi
cmp    (%rsp),%rdx
je     2447 <getP8+0x12f7>
add    $0x1,%rdx
cmp    0x90(%rsp),%rdx
jge    2400 <getP8+0x12b0>
mov    $0x1,%ebp
mov    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdi,%rbp,8),%xmm0
movsd  %xmm0,(%rax)
add    %rcx,%rax
add    $0x1,%rbp
cmp    %rbp,%rsi
jne    2430 <getP8+0x12e0>
jmp    2400 <getP8+0x12b0>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    0x128(%rsp),%rdi
call   1030 <free@plt>
mov    0x120(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rax
add    $0x1f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double* @getP8(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 double*
%36 = alloca double*
%37 = alloca double*
%38 = alloca double*
%39 = alloca double*
%40 = alloca double*
%41 = alloca double*
%42 = alloca double*
%43 = alloca double*
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i32
%52 = alloca i32
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = 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
%60 = load i32, i32* %18
%61 = load i32, i32* %18
%62 = mul nsw i32 %60, %61
%63 = sext i32 %62 to i64
%64 = mul i64 %63, 8
%65 = call i8* @malloc(i64 %64)
%66 = bitcast i8* %65 to double*
store double* %66, double** %20
%67 = load i32, i32* %17
%68 = icmp eq i32 %67, 0
br i1 %68, label %69, label %86
69: ; preds = %9
store i32 0, i32* %21
br label %70
70: ; preds = %81, %69
%71 = load i32, i32* %21
%72 = load i32, i32* %18
%73 = load i32, i32* %18
%74 = mul nsw i32 %72, %73
%75 = icmp slt i32 %71, %74
br i1 %75, label %76, label %84
76: ; preds = %70
%77 = load double*, double** %20
%78 = load i32, i32* %21
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
store double 0.000000e+00, double* %80
br label %81
81: ; preds = %76
%82 = load i32, i32* %21
%83 = add nsw i32 %82, 1
store i32 %83, i32* %21
br label %70
84: ; preds = %70
%85 = load double*, double** %20
store double* %85, double** %10
br label %906
86: ; preds = %9
store double 0.000000e+00, double* %22
store double 0.000000e+00, double* %23
store double 0.000000e+00, double* %26
store double 0.000000e+00, double* %27
store double 0.000000e+00, double* %28
store double 0.000000e+00, double* %29
store double 0.000000e+00, double* %30
store double 0.000000e+00, double* %31
store double 0.000000e+00, double* %32
%87 = load i32, i32* %18
%88 = sext i32 %87 to i64
%89 = mul i64 %88, 8
%90 = call i8* @malloc(i64 %89)
%91 = bitcast i8* %90 to double*
store double* %91, double** %33
%92 = load i32, i32* %18
%93 = sext i32 %92 to i64
%94 = mul i64 %93, 8
%95 = call i8* @malloc(i64 %94)
%96 = bitcast i8* %95 to double*
store double* %96, double** %34
%97 = load i32, i32* %17
%98 = load i32, i32* %17
%99 = mul nsw i32 %97, %98
%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** %35
%104 = load i32, i32* %17
%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** %36
%109 = load i32, i32* %17
%110 = sext i32 %109 to i64
%111 = mul i64 %110, 8
%112 = call i8* @malloc(i64 %111)
%113 = bitcast i8* %112 to double*
store double* %113, double** %37
%114 = load i32, i32* %17
%115 = sext i32 %114 to i64
%116 = mul i64 %115, 8
%117 = call i8* @malloc(i64 %116)
%118 = bitcast i8* %117 to double*
store double* %118, double** %38
%119 = load i32, i32* %17
%120 = sext i32 %119 to i64
%121 = mul i64 %120, 8
%122 = call i8* @malloc(i64 %121)
%123 = bitcast i8* %122 to double*
store double* %123, double** %39
%124 = load i32, i32* %17
%125 = sext i32 %124 to i64
%126 = mul i64 %125, 8
%127 = call i8* @malloc(i64 %126)
%128 = bitcast i8* %127 to double*
store double* %128, double** %40
%129 = load i32, i32* %17
%130 = sext i32 %129 to i64
%131 = mul i64 %130, 8
%132 = call i8* @malloc(i64 %131)
%133 = bitcast i8* %132 to double*
store double* %133, double** %41
%134 = load i32, i32* %17
%135 = sext i32 %134 to i64
%136 = mul i64 %135, 8
%137 = call i8* @malloc(i64 %136)
%138 = bitcast i8* %137 to double*
store double* %138, double** %42
%139 = load i32, i32* %18
%140 = load i32, i32* %18
%141 = mul nsw i32 %139, %140
%142 = load i32, i32* %17
%143 = mul nsw i32 %141, %142
%144 = load i32, i32* %17
%145 = mul nsw i32 %143, %144
%146 = sext i32 %145 to i64
%147 = mul i64 %146, 8
%148 = call i8* @malloc(i64 %147)
%149 = bitcast i8* %148 to double*
store double* %149, double** %43
store i32 0, i32* %44
br label %150
150: ; preds = %204, %86
%151 = load i32, i32* %44
%152 = load i32, i32* %18
%153 = icmp slt i32 %151, %152
br i1 %153, label %154, label %207
154: ; preds = %150
%155 = load double*, double** %15
%156 = load i32, i32* %18
%157 = mul nsw i32 8, %156
%158 = load i32, i32* %44
%159 = add nsw i32 %157, %158
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double, double* %155, i64 %160
%162 = load double, double* %161
%163 = fadd double 1.000000e+00, %162
%164 = fdiv double 1.000000e+00, %163
store double %164, double* %24
%165 = load double, double* %24
%166 = call double @sqrt(double %165)
store double %166, double* %25
%167 = load double, double* %25
%168 = load double, double* %24
%169 = fmul double %167, %168
%170 = load double, double* %24
%171 = fmul double %169, %170
%172 = load double, double* %24
%173 = fmul double %171, %172
%174 = load double, double* %24
%175 = fmul double %173, %174
%176 = load double, double* %24
%177 = fmul double %175, %176
%178 = load double, double* %24
%179 = fmul double %177, %178
%180 = load double, double* %24
%181 = fmul double %179, %180
%182 = load double, double* %24
%183 = fmul double %181, %182
%184 = load double, double* %24
%185 = fmul double %183, %184
%186 = load double*, double** %34
%187 = load i32, i32* %44
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double, double* %186, i64 %188
store double %185, double* %189
%190 = load double*, double** %15
%191 = load i32, i32* %18
%192 = mul nsw i32 8, %191
%193 = load i32, i32* %44
%194 = add nsw i32 %192, %193
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds double, double* %190, i64 %195
%197 = load double, double* %196
%198 = load double, double* %24
%199 = fmul double %197, %198
%200 = load double*, double** %33
%201 = load i32, i32* %44
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %200, i64 %202
store double %199, double* %203
br label %204
204: ; preds = %154
%205 = load i32, i32* %44
%206 = add nsw i32 %205, 1
store i32 %206, i32* %44
br label %150
207: ; preds = %150
store i32 0, i32* %45
br label %208
208: ; preds = %380, %207
%209 = load i32, i32* %45
%210 = load i32, i32* %17
%211 = icmp slt i32 %209, %210
br i1 %211, label %212, label %383
212: ; preds = %208
%213 = load double*, double** %13
%214 = load i32, i32* %45
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %213, i64 %215
%217 = load double, double* %216
%218 = load double*, double** %13
%219 = load i32, i32* %45
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %218, i64 %220
%222 = load double, double* %221
%223 = fmul double %217, %222
store double %223, double* %26
%224 = load double, double* %26
%225 = load double, double* %26
%226 = fmul double %224, %225
store double %226, double* %27
%227 = load double, double* %26
%228 = load double, double* %27
%229 = fmul double %227, %228
store double %229, double* %28
%230 = load double, double* %27
%231 = load double, double* %27
%232 = fmul double %230, %231
store double %232, double* %29
%233 = load double*, double** %14
%234 = load i32, i32* %45
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %233, i64 %235
%237 = load double, double* %236
%238 = load double*, double** %14
%239 = load i32, i32* %45
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %238, i64 %240
%242 = load double, double* %241
%243 = fmul double %237, %242
store double %243, double* %30
%244 = load double, double* %30
%245 = load double*, double** %14
%246 = load i32, i32* %45
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %245, i64 %247
%249 = load double, double* %248
%250 = fmul double %244, %249
store double %250, double* %31
%251 = load double, double* %30
%252 = load double, double* %30
%253 = fmul double %251, %252
store double %253, double* %32
%254 = load double, double* %26
%255 = load double*, double** %14
%256 = load i32, i32* %45
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %255, i64 %257
%259 = load double, double* %258
%260 = fneg double %259
%261 = call double @llvm.fmuladd.f64(double 5.000000e+00, double %254, double %260)
%262 = load double*, double** %37
%263 = load i32, i32* %45
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds double, double* %262, i64 %264
store double %261, double* %265
%266 = load double, double* %26
%267 = load double*, double** %14
%268 = load i32, i32* %45
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds double, double* %267, i64 %269
%271 = load double, double* %270
%272 = fneg double %271
%273 = call double @llvm.fmuladd.f64(double 1.500000e+01, double %266, double %272)
%274 = load double*, double** %36
%275 = load i32, i32* %45
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %274, i64 %276
store double %273, double* %277
%278 = load double, double* %27
%279 = load double, double* %26
%280 = fmul double 2.600000e+01, %279
%281 = load double*, double** %14
%282 = load i32, i32* %45
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %281, i64 %283
%285 = load double, double* %284
%286 = fmul double %280, %285
%287 = fneg double %286
%288 = call double @llvm.fmuladd.f64(double 6.500000e+01, double %278, double %287)
%289 = load double, double* %30
%290 = fadd double %288, %289
%291 = load double*, double** %38
%292 = load i32, i32* %45
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double, double* %291, i64 %293
store double %290, double* %294
%295 = load double, double* %27
%296 = load double, double* %26
%297 = fmul double 2.600000e+01, %296
%298 = load double*, double** %14
%299 = load i32, i32* %45
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double, double* %298, i64 %300
%302 = load double, double* %301
%303 = fmul double %297, %302
%304 = fneg double %303
%305 = call double @llvm.fmuladd.f64(double 3.900000e+01, double %295, double %304)
%306 = load double, double* %30
%307 = call double @llvm.fmuladd.f64(double 3.000000e+00, double %306, double %305)
%308 = load double*, double** %39
%309 = load i32, i32* %45
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds double, double* %308, i64 %310
store double %307, double* %311
%312 = load double, double* %28
%313 = load double, double* %27
%314 = fmul double 1.430000e+02, %313
%315 = load double*, double** %14
%316 = load i32, i32* %45
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double, double* %315, i64 %317
%319 = load double, double* %318
%320 = fmul double %314, %319
%321 = fneg double %320
%322 = call double @llvm.fmuladd.f64(double 1.430000e+02, double %312, double %321)
%323 = load double, double* %26
%324 = fmul double 3.300000e+01, %323
%325 = load double, double* %30
%326 = call double @llvm.fmuladd.f64(double %324, double %325, double %322)
%327 = load double, double* %31
%328 = fsub double %326, %327
%329 = load double*, double** %40
%330 = load i32, i32* %45
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds double, double* %329, i64 %331
store double %328, double* %332
%333 = load double, double* %28
%334 = load double, double* %27
%335 = fmul double 1.001000e+03, %334
%336 = load double*, double** %14
%337 = load i32, i32* %45
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds double, double* %336, i64 %338
%340 = load double, double* %339
%341 = fmul double %335, %340
%342 = fneg double %341
%343 = call double @llvm.fmuladd.f64(double 7.150000e+02, double %333, double %342)
%344 = load double, double* %26
%345 = fmul double 3.850000e+02, %344
%346 = load double, double* %30
%347 = call double @llvm.fmuladd.f64(double %345, double %346, double %343)
%348 = load double, double* %31
%349 = call double @llvm.fmuladd.f64(double -3.500000e+01, double %348, double %347)
%350 = load double*, double** %41
%351 = load i32, i32* %45
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %350, i64 %352
store double %349, double* %353
%354 = load double, double* %29
%355 = load double, double* %28
%356 = fmul double 1.201200e+04, %355
%357 = load double*, double** %14
%358 = load i32, i32* %45
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds double, double* %357, i64 %359
%361 = load double, double* %360
%362 = fmul double %356, %361
%363 = fneg double %362
%364 = call double @llvm.fmuladd.f64(double 6.435000e+03, double %354, double %363)
%365 = load double, double* %27
%366 = fmul double 6.930000e+03, %365
%367 = load double, double* %30
%368 = call double @llvm.fmuladd.f64(double %366, double %367, double %364)
%369 = load double, double* %26
%370 = fmul double 1.260000e+03, %369
%371 = load double, double* %31
%372 = fneg double %370
%373 = call double @llvm.fmuladd.f64(double %372, double %371, double %368)
%374 = load double, double* %32
%375 = call double @llvm.fmuladd.f64(double 3.500000e+01, double %374, double %373)
%376 = load double*, double** %42
%377 = load i32, i32* %45
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds double, double* %376, i64 %378
store double %375, double* %379
br label %380
380: ; preds = %212
%381 = load i32, i32* %45
%382 = add nsw i32 %381, 1
store i32 %382, i32* %45
br label %208
383: ; preds = %208
store i32 0, i32* %46
br label %384
384: ; preds = %615, %383
%385 = load i32, i32* %46
%386 = load i32, i32* %17
%387 = icmp slt i32 %385, %386
br i1 %387, label %388, label %618
388: ; preds = %384
store i32 0, i32* %47
br label %389
389: ; preds = %611, %388
%390 = load i32, i32* %47
%391 = load i32, i32* %17
%392 = icmp slt i32 %390, %391
br i1 %392, label %393, label %614
393: ; preds = %389
%394 = load double*, double** %13
%395 = load i32, i32* %46
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double, double* %394, i64 %396
%398 = load double, double* %397
%399 = load double*, double** %13
%400 = load i32, i32* %47
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds double, double* %399, i64 %401
%403 = load double, double* %402
%404 = fmul double %398, %403
%405 = load double*, double** %19
%406 = load i32, i32* %17
%407 = mul nsw i32 6, %406
%408 = load i32, i32* %17
%409 = mul nsw i32 %407, %408
%410 = load i32, i32* %46
%411 = load i32, i32* %17
%412 = mul nsw i32 %410, %411
%413 = add nsw i32 %409, %412
%414 = load i32, i32* %47
%415 = add nsw i32 %413, %414
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds double, double* %405, i64 %416
%418 = load double, double* %417
%419 = load double*, double** %37
%420 = load i32, i32* %46
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds double, double* %419, i64 %421
%423 = load double, double* %422
%424 = fmul double 1.441440e+05, %423
%425 = load double*, double** %37
%426 = load i32, i32* %47
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds double, double* %425, i64 %427
%429 = load double, double* %428
%430 = fmul double %424, %429
%431 = load double*, double** %19
%432 = load i32, i32* %17
%433 = mul nsw i32 4, %432
%434 = load i32, i32* %17
%435 = mul nsw i32 %433, %434
%436 = load i32, i32* %46
%437 = load i32, i32* %17
%438 = mul nsw i32 %436, %437
%439 = add nsw i32 %435, %438
%440 = load i32, i32* %47
%441 = add nsw i32 %439, %440
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds double, double* %431, i64 %442
%444 = load double, double* %443
%445 = fmul double %430, %444
%446 = call double @llvm.fmuladd.f64(double 1.029600e+05, double %418, double %445)
%447 = load double*, double** %39
%448 = load i32, i32* %46
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds double, double* %447, i64 %449
%451 = load double, double* %450
%452 = fmul double 1.848000e+04, %451
%453 = load double*, double** %39
%454 = load i32, i32* %47
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %453, i64 %455
%457 = load double, double* %456
%458 = fmul double %452, %457
%459 = load double*, double** %19
%460 = load i32, i32* %17
%461 = mul nsw i32 2, %460
%462 = load i32, i32* %17
%463 = mul nsw i32 %461, %462
%464 = load i32, i32* %46
%465 = load i32, i32* %17
%466 = mul nsw i32 %464, %465
%467 = add nsw i32 %463, %466
%468 = load i32, i32* %47
%469 = add nsw i32 %467, %468
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds double, double* %459, i64 %470
%472 = load double, double* %471
%473 = call double @llvm.fmuladd.f64(double %458, double %472, double %446)
%474 = load double*, double** %41
%475 = load i32, i32* %46
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds double, double* %474, i64 %476
%478 = load double, double* %477
%479 = fmul double 1.440000e+02, %478
%480 = load double*, double** %41
%481 = load i32, i32* %47
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds double, double* %480, i64 %482
%484 = load double, double* %483
%485 = fmul double %479, %484
%486 = load double*, double** %19
%487 = load i32, i32* %46
%488 = load i32, i32* %17
%489 = mul nsw i32 %487, %488
%490 = load i32, i32* %47
%491 = add nsw i32 %489, %490
%492 = sext i32 %491 to i64
%493 = getelementptr inbounds double, double* %486, i64 %492
%494 = load double, double* %493
%495 = call double @llvm.fmuladd.f64(double %485, double %494, double %473)
%496 = load double*, double** %19
%497 = load i32, i32* %17
%498 = mul nsw i32 7, %497
%499 = load i32, i32* %17
%500 = mul nsw i32 %498, %499
%501 = load i32, i32* %46
%502 = load i32, i32* %17
%503 = mul nsw i32 %501, %502
%504 = add nsw i32 %500, %503
%505 = load i32, i32* %47
%506 = add nsw i32 %504, %505
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds double, double* %496, i64 %507
%509 = load double, double* %508
%510 = fmul double 6.435000e+03, %509
%511 = call double @llvm.fmuladd.f64(double %404, double %495, double %510)
%512 = load double*, double** %36
%513 = load i32, i32* %46
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds double, double* %512, i64 %514
%516 = load double, double* %515
%517 = fmul double 3.432000e+03, %516
%518 = load double*, double** %36
%519 = load i32, i32* %47
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds double, double* %518, i64 %520
%522 = load double, double* %521
%523 = fmul double %517, %522
%524 = load double*, double** %19
%525 = load i32, i32* %17
%526 = mul nsw i32 5, %525
%527 = load i32, i32* %17
%528 = mul nsw i32 %526, %527
%529 = load i32, i32* %46
%530 = load i32, i32* %17
%531 = mul nsw i32 %529, %530
%532 = add nsw i32 %528, %531
%533 = load i32, i32* %47
%534 = add nsw i32 %532, %533
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds double, double* %524, i64 %535
%537 = load double, double* %536
%538 = call double @llvm.fmuladd.f64(double %523, double %537, double %511)
%539 = load double*, double** %38
%540 = load i32, i32* %46
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds double, double* %539, i64 %541
%543 = load double, double* %542
%544 = fmul double 2.772000e+03, %543
%545 = load double*, double** %38
%546 = load i32, i32* %47
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds double, double* %545, i64 %547
%549 = load double, double* %548
%550 = fmul double %544, %549
%551 = load double*, double** %19
%552 = load i32, i32* %17
%553 = mul nsw i32 3, %552
%554 = load i32, i32* %17
%555 = mul nsw i32 %553, %554
%556 = load i32, i32* %46
%557 = load i32, i32* %17
%558 = mul nsw i32 %556, %557
%559 = add nsw i32 %555, %558
%560 = load i32, i32* %47
%561 = add nsw i32 %559, %560
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds double, double* %551, i64 %562
%564 = load double, double* %563
%565 = call double @llvm.fmuladd.f64(double %550, double %564, double %538)
%566 = load double*, double** %40
%567 = load i32, i32* %46
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds double, double* %566, i64 %568
%570 = load double, double* %569
%571 = fmul double 2.520000e+03, %570
%572 = load double*, double** %40
%573 = load i32, i32* %47
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds double, double* %572, i64 %574
%576 = load double, double* %575
%577 = fmul double %571, %576
%578 = load double*, double** %19
%579 = load i32, i32* %17
%580 = load i32, i32* %17
%581 = mul nsw i32 %579, %580
%582 = load i32, i32* %46
%583 = load i32, i32* %17
%584 = mul nsw i32 %582, %583
%585 = add nsw i32 %581, %584
%586 = load i32, i32* %47
%587 = add nsw i32 %585, %586
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds double, double* %578, i64 %588
%590 = load double, double* %589
%591 = call double @llvm.fmuladd.f64(double %577, double %590, double %565)
%592 = load double*, double** %42
%593 = load i32, i32* %46
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds double, double* %592, i64 %594
%596 = load double, double* %595
%597 = load double*, double** %42
%598 = load i32, i32* %47
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds double, double* %597, i64 %599
%601 = load double, double* %600
%602 = call double @llvm.fmuladd.f64(double %596, double %601, double %591)
%603 = load double*, double** %35
%604 = load i32, i32* %46
%605 = load i32, i32* %17
%606 = mul nsw i32 %604, %605
%607 = load i32, i32* %47
%608 = add nsw i32 %606, %607
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds double, double* %603, i64 %609
store double %602, double* %610
br label %611
611: ; preds = %393
%612 = load i32, i32* %47
%613 = add nsw i32 %612, 1
store i32 %613, i32* %47
br label %389
614: ; preds = %389
br label %615
615: ; preds = %614
%616 = load i32, i32* %46
%617 = add nsw i32 %616, 1
store i32 %617, i32* %46
br label %384
618: ; preds = %384
store i32 0, i32* %48
br label %619
619: ; preds = %708, %618
%620 = load i32, i32* %48
%621 = load i32, i32* %18
%622 = icmp slt i32 %620, %621
br i1 %622, label %623, label %711
623: ; preds = %619
store i32 0, i32* %49
br label %624
624: ; preds = %704, %623
%625 = load i32, i32* %49
%626 = load i32, i32* %18
%627 = icmp slt i32 %625, %626
br i1 %627, label %628, label %707
628: ; preds = %624
store i32 0, i32* %50
br label %629
629: ; preds = %700, %628
%630 = load i32, i32* %50
%631 = load i32, i32* %17
%632 = icmp slt i32 %630, %631
br i1 %632, label %633, label %703
633: ; preds = %629
store i32 0, i32* %51
br label %634
634: ; preds = %696, %633
%635 = load i32, i32* %51
%636 = load i32, i32* %17
%637 = icmp slt i32 %635, %636
br i1 %637, label %638, label %699
638: ; preds = %634
%639 = load double*, double** %35
%640 = load i32, i32* %50
%641 = load i32, i32* %17
%642 = mul nsw i32 %640, %641
%643 = load i32, i32* %51
%644 = add nsw i32 %642, %643
%645 = sext i32 %644 to i64
%646 = getelementptr inbounds double, double* %639, i64 %645
%647 = load double, double* %646
%648 = load double*, double** %33
%649 = load i32, i32* %48
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds double, double* %648, i64 %650
%652 = load double, double* %651
%653 = fneg double %652
%654 = load double*, double** %14
%655 = load i32, i32* %50
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds double, double* %654, i64 %656
%658 = load double, double* %657
%659 = load double*, double** %33
%660 = load i32, i32* %49
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds double, double* %659, i64 %661
%663 = load double, double* %662
%664 = load double*, double** %14
%665 = load i32, i32* %51
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds double, double* %664, i64 %666
%668 = load double, double* %667
%669 = fmul double %663, %668
%670 = fneg double %669
%671 = call double @llvm.fmuladd.f64(double %653, double %658, double %670)
%672 = call double @exp(double %671)
%673 = fmul double %647, %672
%674 = load double*, double** %43
%675 = load i32, i32* %48
%676 = load i32, i32* %18
%677 = mul nsw i32 %675, %676
%678 = load i32, i32* %17
%679 = mul nsw i32 %677, %678
%680 = load i32, i32* %17
%681 = mul nsw i32 %679, %680
%682 = load i32, i32* %49
%683 = load i32, i32* %17
%684 = mul nsw i32 %682, %683
%685 = load i32, i32* %17
%686 = mul nsw i32 %684, %685
%687 = add nsw i32 %681, %686
%688 = load i32, i32* %50
%689 = load i32, i32* %17
%690 = mul nsw i32 %688, %689
%691 = add nsw i32 %687, %690
%692 = load i32, i32* %51
%693 = add nsw i32 %691, %692
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds double, double* %674, i64 %694
store double %673, double* %695
br label %696
696: ; preds = %638
%697 = load i32, i32* %51
%698 = add nsw i32 %697, 1
store i32 %698, i32* %51
br label %634
699: ; preds = %634
br label %700
700: ; preds = %699
%701 = load i32, i32* %50
%702 = add nsw i32 %701, 1
store i32 %702, i32* %50
br label %629
703: ; preds = %629
br label %704
704: ; preds = %703
%705 = load i32, i32* %49
%706 = add nsw i32 %705, 1
store i32 %706, i32* %49
br label %624
707: ; preds = %624
br label %708
708: ; preds = %707
%709 = load i32, i32* %48
%710 = add nsw i32 %709, 1
store i32 %710, i32* %48
br label %619
711: ; preds = %619
store i32 0, i32* %52
br label %712
712: ; preds = %842, %711
%713 = load i32, i32* %52
%714 = load i32, i32* %18
%715 = icmp slt i32 %713, %714
br i1 %715, label %716, label %845
716: ; preds = %712
%717 = load i32, i32* %52
store i32 %717, i32* %53
br label %718
718: ; preds = %838, %716
%719 = load i32, i32* %53
%720 = load i32, i32* %18
%721 = icmp slt i32 %719, %720
br i1 %721, label %722, label %841
722: ; preds = %718
store double 0.000000e+00, double* %23
store i32 0, i32* %54
br label %723
723: ; preds = %824, %722
%724 = load i32, i32* %54
%725 = load i32, i32* %18
%726 = icmp slt i32 %724, %725
br i1 %726, label %727, label %827
727: ; preds = %723
store i32 0, i32* %55
br label %728
728: ; preds = %820, %727
%729 = load i32, i32* %55
%730 = load i32, i32* %18
%731 = icmp slt i32 %729, %730
br i1 %731, label %732, label %823
732: ; preds = %728
store double 0.000000e+00, double* %22
store i32 0, i32* %56
br label %733
733: ; preds = %772, %732
%734 = load i32, i32* %56
%735 = load i32, i32* %17
%736 = icmp slt i32 %734, %735
br i1 %736, label %737, label %775
737: ; preds = %733
store i32 0, i32* %57
br label %738
738: ; preds = %768, %737
%739 = load i32, i32* %57
%740 = load i32, i32* %17
%741 = icmp slt i32 %739, %740
br i1 %741, label %742, label %771
742: ; preds = %738
%743 = load double*, double** %43
%744 = load i32, i32* %54
%745 = load i32, i32* %18
%746 = mul nsw i32 %744, %745
%747 = load i32, i32* %17
%748 = mul nsw i32 %746, %747
%749 = load i32, i32* %17
%750 = mul nsw i32 %748, %749
%751 = load i32, i32* %55
%752 = load i32, i32* %17
%753 = mul nsw i32 %751, %752
%754 = load i32, i32* %17
%755 = mul nsw i32 %753, %754
%756 = add nsw i32 %750, %755
%757 = load i32, i32* %56
%758 = load i32, i32* %17
%759 = mul nsw i32 %757, %758
%760 = add nsw i32 %756, %759
%761 = load i32, i32* %57
%762 = add nsw i32 %760, %761
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds double, double* %743, i64 %763
%765 = load double, double* %764
%766 = load double, double* %22
%767 = fadd double %766, %765
store double %767, double* %22
br label %768
768: ; preds = %742
%769 = load i32, i32* %57
%770 = add nsw i32 %769, 1
store i32 %770, i32* %57
br label %738
771: ; preds = %738
br label %772
772: ; preds = %771
%773 = load i32, i32* %56
%774 = add nsw i32 %773, 1
store i32 %774, i32* %56
br label %733
775: ; preds = %733
%776 = load double*, double** %16
%777 = load i32, i32* %18
%778 = mul nsw i32 8, %777
%779 = load i32, i32* %18
%780 = mul nsw i32 %778, %779
%781 = load i32, i32* %52
%782 = load i32, i32* %18
%783 = mul nsw i32 %781, %782
%784 = add nsw i32 %780, %783
%785 = load i32, i32* %54
%786 = add nsw i32 %784, %785
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds double, double* %776, i64 %787
%789 = load double, double* %788
%790 = load double*, double** %16
%791 = load i32, i32* %18
%792 = mul nsw i32 8, %791
%793 = load i32, i32* %18
%794 = mul nsw i32 %792, %793
%795 = load i32, i32* %53
%796 = load i32, i32* %18
%797 = mul nsw i32 %795, %796
%798 = add nsw i32 %794, %797
%799 = load i32, i32* %55
%800 = add nsw i32 %798, %799
%801 = sext i32 %800 to i64
%802 = getelementptr inbounds double, double* %790, i64 %801
%803 = load double, double* %802
%804 = fmul double %789, %803
%805 = load double*, double** %34
%806 = load i32, i32* %54
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds double, double* %805, i64 %807
%809 = load double, double* %808
%810 = fmul double %804, %809
%811 = load double*, double** %34
%812 = load i32, i32* %55
%813 = sext i32 %812 to i64
%814 = getelementptr inbounds double, double* %811, i64 %813
%815 = load double, double* %814
%816 = fmul double %810, %815
%817 = load double, double* %22
%818 = load double, double* %23
%819 = call double @llvm.fmuladd.f64(double %816, double %817, double %818)
store double %819, double* %23
br label %820
820: ; preds = %775
%821 = load i32, i32* %55
%822 = add nsw i32 %821, 1
store i32 %822, i32* %55
br label %728
823: ; preds = %728
br label %824
824: ; preds = %823
%825 = load i32, i32* %54
%826 = add nsw i32 %825, 1
store i32 %826, i32* %54
br label %723
827: ; preds = %723
%828 = load double, double* %23
%829 = fmul double 0x3F64F910965A2A3D, %828
%830 = load double*, double** %20
%831 = load i32, i32* %18
%832 = load i32, i32* %52
%833 = mul nsw i32 %831, %832
%834 = load i32, i32* %53
%835 = add nsw i32 %833, %834
%836 = sext i32 %835 to i64
%837 = getelementptr inbounds double, double* %830, i64 %836
store double %829, double* %837
br label %838
838: ; preds = %827
%839 = load i32, i32* %53
%840 = add nsw i32 %839, 1
store i32 %840, i32* %53
br label %718
841: ; preds = %718
br label %842
842: ; preds = %841
%843 = load i32, i32* %52
%844 = add nsw i32 %843, 1
store i32 %844, i32* %52
br label %712
845: ; preds = %712
store i32 0, i32* %58
br label %846
846: ; preds = %879, %845
%847 = load i32, i32* %58
%848 = load i32, i32* %18
%849 = icmp slt i32 %847, %848
br i1 %849, label %850, label %882
850: ; preds = %846
%851 = load i32, i32* %58
%852 = add nsw i32 %851, 1
store i32 %852, i32* %59
br label %853
853: ; preds = %875, %850
%854 = load i32, i32* %59
%855 = load i32, i32* %18
%856 = icmp slt i32 %854, %855
br i1 %856, label %857, label %878
857: ; preds = %853
%858 = load double*, double** %20
%859 = load i32, i32* %18
%860 = load i32, i32* %58
%861 = mul nsw i32 %859, %860
%862 = load i32, i32* %59
%863 = add nsw i32 %861, %862
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds double, double* %858, i64 %864
%866 = load double, double* %865
%867 = load double*, double** %20
%868 = load i32, i32* %18
%869 = load i32, i32* %59
%870 = mul nsw i32 %868, %869
%871 = load i32, i32* %58
%872 = add nsw i32 %870, %871
%873 = sext i32 %872 to i64
%874 = getelementptr inbounds double, double* %867, i64 %873
store double %866, double* %874
br label %875
875: ; preds = %857
%876 = load i32, i32* %59
%877 = add nsw i32 %876, 1
store i32 %877, i32* %59
br label %853
878: ; preds = %853
br label %879
879: ; preds = %878
%880 = load i32, i32* %58
%881 = add nsw i32 %880, 1
store i32 %881, i32* %58
br label %846
882: ; preds = %846
%883 = load double*, double** %34
%884 = bitcast double* %883 to i8*
%885 = load double*, double** %33
%886 = bitcast double* %885 to i8*
%887 = load double*, double** %35
%888 = bitcast double* %887 to i8*
%889 = load double*, double** %36
%890 = bitcast double* %889 to i8*
%891 = load double*, double** %37
%892 = bitcast double* %891 to i8*
%893 = load double*, double** %38
%894 = bitcast double* %893 to i8*
%895 = load double*, double** %39
%896 = bitcast double* %895 to i8*
%897 = load double*, double** %40
%898 = bitcast double* %897 to i8*
%899 = load double*, double** %41
%900 = bitcast double* %899 to i8*
%901 = load double*, double** %42
%902 = bitcast double* %901 to i8*
%903 = load double*, double** %43
%904 = bitcast double* %903 to i8*
%905 = load double*, double** %20
store double* %905, double** %10
br label %906
906: ; preds = %882, %84
%907 = load double*, double** %10
ret double* %907
}

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