double *getP6(double *x, double *y, double *z, double *r2, double *alphas,
              double *betas, int Asize, int Nsize, double *ReX) {
  double *P6 = (double *)malloc(Nsize * Nsize * sizeof(double));
  if (Asize == 0) {
    for (int n = 0; n < Nsize * Nsize; n++) {
      P6[n] = 0.0;
    }
    return P6;
  }
  double sumsInner = 0;
  double sumsOuter = 0;
  double oneO1Palpha;
  double oneO1PalphaSqrt;
  double z2 = 0;
  double r4 = 0;
  double *alphaO1Palpha = (double *)malloc(Nsize * sizeof(double));
  double *oneO1PalphaSqrt15 = (double *)malloc(Nsize * sizeof(double));
  double *ReXStripe = (double *)malloc(Asize * Asize * sizeof(double));
  double *zr11 = (double *)malloc(Asize * sizeof(double));
  double *zr113 = (double *)malloc(Asize * sizeof(double));
  double *zr3311 = (double *)malloc(Asize * sizeof(double));
  double *zr3330 = (double *)malloc(Asize * sizeof(double));
  double *zr231 = (double *)malloc(Asize * sizeof(double));
  double *kkdij =
      (double *)malloc(Nsize * Nsize * Asize * Asize * sizeof(double));
  for (int n = 0; n < Nsize; n++) {
    oneO1Palpha = 1.0 / (1.00000000 + alphas[6 * Nsize + n]);
    oneO1PalphaSqrt = sqrt(oneO1Palpha);
    oneO1PalphaSqrt15[n] = oneO1PalphaSqrt * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha;
    alphaO1Palpha[n] = alphas[6 * Nsize + n] * oneO1Palpha;
  }
  for (int i = 0; i < Asize; i++) {
    z2 = z[i] * z[i];
    r4 = r2[i] * r2[i];
    zr11[i] = 11 * z2 - r2[i];
    zr113[i] = 11 * z2 - 3 * r2[i];
    zr3311[i] = 33 * z2 * z2 - 18 * z2 * r2[i] + r4;
    zr3330[i] = 33 * z2 * z2 - 30 * z2 * r2[i] + 5 * r4;
    zr231[i] = 231 * z2 * z2 * z2 - 315 * z2 * z2 * r2[i] + 105 * z2 * r4 -
               5 * r2[i] * r4;
  }
  for (int i = 0; i < Asize; i++) {
    for (int j = 0; j < Asize; j++) {
      ReXStripe[i * Asize + j] =
          115.5 * ReX[5 * Asize * Asize + i * Asize + j] +
          z[i] * z[j] *
              (1386 * ReX[4 * Asize * Asize + i * Asize + j] +
               210 * zr113[i] * zr113[j] *
                   ReX[2 * Asize * Asize + i * Asize + j] +
               84 * zr3330[i] * zr3330[j] * ReX[i * Asize + j]) +
          63 * zr11[i] * zr11[j] * ReX[3 * Asize * Asize + i * Asize + j] +
          52.5 * zr3311[i] * zr3311[j] * ReX[Asize * Asize + i * Asize + j] +
          zr231[i] * zr231[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[6 * Nsize * Nsize + n * Nsize + k] *
                       betas[6 * Nsize * Nsize + nd * Nsize + kd] *
                       oneO1PalphaSqrt15[k] * oneO1PalphaSqrt15[kd] * sumsInner;
        }
      }
      P6[Nsize * n + nd] = 13.0 * 9.86960440108936 * 9.765625e-4 * sumsOuter;
    }
  }
  for (int n = 0; n < Nsize; n++) {
    for (int nd = n + 1; nd < Nsize; nd++) {
      P6[Nsize * nd + n] = P6[Nsize * n + nd];
    }
  }
  free(oneO1PalphaSqrt15);
  free(alphaO1Palpha);
  free(ReXStripe);
  free(zr11);
  free(zr113);
  free(zr3311);
  free(zr3330);
  free(zr231);
  free(kkdij);
  return P6;
}


x86 assembly (clang, -O0):
<getP6>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%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 <getP6+0x92>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    11c5 <getP6+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 <getP6+0x55>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1dd1 <getP6+0xc91>
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)
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    0x10(%rbp),%eax
imul   0x10(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xb8(%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,-0xc0(%rbp)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1388 <getP6+0x248>
mov    -0x30(%rbp),%rax
imul   $0x6,0x18(%rbp),%ecx
add    -0xc4(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd97(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  0xd8a(%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
mov    -0x88(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
imul   $0x6,0x18(%rbp),%ecx
add    -0xc4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    12c1 <getP6+0x181>
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1642 <getP6+0x502>
mov    -0x20(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xc8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xc51(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0xc26(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xbfa(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xbc7(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  0xbbd(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xc8(%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
addsd  -0x78(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xb61(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  0xb47(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  0xae6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xadb(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  0xabc(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xc8(%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
movsd  0xa73(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0xa46(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1392 <getP6+0x252>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    18df <getP6+0x79f>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    18c6 <getP6+0x786>
mov    0x20(%rbp),%rax
imul   $0x5,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xcc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x2,%ecx
imul   0x10(%rbp),%ecx
mov    -0xcc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0xa0(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  0x938(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
mov    -0xa0(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   0x10(%rbp),%ecx
mov    -0xcc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
movsd  0x8e8(%rip),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0xb0(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  0x8c2(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
mov    -0xb0(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0xcc(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
movsd  0x872(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x98(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  0x84c(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x98(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
imul   $0x3,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xcc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  0x7e8(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0xa8(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xcc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xb8(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
mov    -0xcc(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    1665 <getP6+0x525>
jmp    18cb <getP6+0x78b>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    164c <getP6+0x50c>
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1a96 <getP6+0x956>
movl   $0x0,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1a7d <getP6+0x93d>
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1a64 <getP6+0x924>
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1a4b <getP6+0x90b>
mov    -0x90(%rbp),%rax
mov    -0xdc(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xe0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x80(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x80(%rbp),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xe0(%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  -0x108(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
mov    -0xd4(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xd8(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0xdc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xe0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    1934 <getP6+0x7f4>
jmp    1a50 <getP6+0x910>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    191b <getP6+0x7db>
jmp    1a69 <getP6+0x929>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1902 <getP6+0x7c2>
jmp    1a82 <getP6+0x942>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    18e9 <getP6+0x7a9>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1cc4 <getP6+0xb84>
mov    -0xe4(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1cab <getP6+0xb6b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xec(%rbp)
mov    -0xec(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1c6e <getP6+0xb2e>
movl   $0x0,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1c55 <getP6+0xb15>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1bb8 <getP6+0xa78>
movl   $0x0,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1b9f <getP6+0xa5f>
mov    -0xc0(%rbp),%rax
mov    -0xec(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xf0(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0xf4(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xf8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf8(%rbp)
jmp    1b2f <getP6+0x9ef>
jmp    1ba4 <getP6+0xa64>
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    1b16 <getP6+0x9d6>
mov    -0x38(%rbp),%rax
imul   $0x6,0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
mov    -0xe4(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
imul   $0x6,0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
mov    -0xe8(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0xec(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0xf0(%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    -0xf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf0(%rbp)
jmp    1af5 <getP6+0x9b5>
jmp    1c5a <getP6+0xb1a>
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    1adc <getP6+0x99c>
movsd  0x38a(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    1abb <getP6+0x97b>
jmp    1cb0 <getP6+0xb70>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1aa0 <getP6+0x960>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1d60 <getP6+0xc20>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1d47 <getP6+0xc07>
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xfc(%rbp),%ecx
add    -0x100(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x100(%rbp),%ecx
add    -0xfc(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    1cec <getP6+0xbac>
jmp    1d4c <getP6+0xc0c>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    1cce <getP6+0xb8e>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getP6>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,0x100(%rsp)
mov    %r8,%r12
mov    %rcx,0x60(%rsp)
mov    %rdx,%r14
mov    0x198(%rsp),%r13d
mov    0x190(%rsp),%r15d
mov    %r13d,%ebp
imul   %ebp,%ebp
lea    0x0(,%rbp,8),%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x70(%rsp)
test   %r15d,%r15d
je     1376 <getP6+0x226>
mov    %r14,0x118(%rsp)
movslq %r13d,%rax
mov    %rax,0x78(%rsp)
lea    0x0(,%rax,8),%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0xe8(%rsp)
mov    %rbx,0x110(%rsp)
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    %r15d,%r14d
imul   %r14d,%r14d
lea    0x0(,%r14,8),%rdi
call   1050 <malloc@plt>
mov    %rax,0xe0(%rsp)
movslq %r15d,%rbx
shl    $0x3,%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %rbx,0x80(%rsp)
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %r14,0x68(%rsp)
mov    %r14d,%eax
mov    %rbp,0x108(%rsp)
imul   %ebp,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %r13d,%eax
mov    %rax,0x8(%rsp)
test   %r13d,%r13d
jle    1337 <getP6+0x1e7>
mov    0x198(%rsp),%eax
add    %eax,%eax
lea    (%rax,%rax,2),%eax
cltq
lea    (%r12,%rax,8),%rbx
xor    %ebp,%ebp
movsd  0x1d5d(%rip),%xmm1
xorpd  %xmm2,%xmm2
jmp    1317 <getP6+0x1c7>
nopl   0x0(%rax)
movapd %xmm3,%xmm0
movsd  %xmm3,0x48(%rsp)
call   1070 <sqrt@plt>
movsd  0x48(%rsp),%xmm3
xorpd  %xmm2,%xmm2
movsd  0x1d2f(%rip),%xmm1
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mov    0x88(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
mulsd  (%rbx,%rbp,8),%xmm3
mov    0xe8(%rsp),%rax
movsd  %xmm3,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,0x8(%rsp)
je     1337 <getP6+0x1e7>
movsd  (%rbx,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
divsd  %xmm0,%xmm3
ucomisd %xmm2,%xmm3
jb     12b0 <getP6+0x160>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    12d1 <getP6+0x181>
mov    %r15,0x48(%rsp)
mov    0x190(%rsp),%ebx
mov    %ebx,%r15d
test   %ebx,%ebx
mov    0x118(%rsp),%r14
jle    1c32 <getP6+0xae2>
cmp    $0x1,%ebx
jne    1392 <getP6+0x242>
xor    %edi,%edi
mov    0x40(%rsp),%r8
mov    0x38(%rsp),%r11
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rbp
jmp    14ed <getP6+0x39d>
test   %ebp,%ebp
je     20db <getP6+0xf8b>
mov    0x70(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
jmp    20db <getP6+0xf8b>
mov    %r15d,%edi
and    $0xfffffffe,%edi
xor    %eax,%eax
movapd 0x1ced(%rip),%xmm8
movapd 0x1cf4(%rip),%xmm9
movapd 0x1cfb(%rip),%xmm10
movapd 0x1d02(%rip),%xmm11
movapd 0x1d09(%rip),%xmm12
movapd 0x1d10(%rip),%xmm13
movapd 0x1d17(%rip),%xmm14
movapd 0x1d1e(%rip),%xmm15
movapd 0x1d26(%rip),%xmm0
movapd 0x1d2e(%rip),%xmm1
mov    0x40(%rsp),%r8
mov    0x38(%rsp),%r11
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rbp
mov    0x60(%rsp),%rcx
mov    0x10(%rsp),%rdx
movupd (%r14,%rax,8),%xmm2
mulpd  %xmm2,%xmm2
movupd (%rcx,%rax,8),%xmm4
movapd %xmm4,%xmm6
mulpd  %xmm4,%xmm6
movapd %xmm2,%xmm5
mulpd  %xmm8,%xmm5
movapd %xmm4,%xmm3
mulpd  %xmm9,%xmm3
addpd  %xmm5,%xmm3
subpd  %xmm4,%xmm5
movupd %xmm5,(%rdx,%rax,8)
movupd %xmm3,(%r8,%rax,8)
movapd %xmm2,%xmm3
mulpd  %xmm10,%xmm3
movapd %xmm2,%xmm5
mulpd  %xmm11,%xmm5
mulpd  %xmm4,%xmm5
mulpd  %xmm2,%xmm3
addpd  %xmm3,%xmm5
addpd  %xmm6,%xmm5
movupd %xmm5,(%r11,%rax,8)
movapd %xmm2,%xmm5
mulpd  %xmm12,%xmm5
mulpd  %xmm4,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm2,%xmm3
mulpd  %xmm14,%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm2,%xmm7
mulpd  %xmm15,%xmm7
mulpd  %xmm2,%xmm7
mulpd  %xmm4,%xmm7
mulpd  %xmm2,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm6,%xmm2
mulpd  %xmm1,%xmm4
mulpd  %xmm6,%xmm4
mulpd  %xmm13,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%rsi,%rax,8)
addpd  %xmm7,%xmm3
addpd  %xmm3,%xmm2
addpd  %xmm2,%xmm4
movupd %xmm4,0x0(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1410 <getP6+0x2c0>
cmp    %r15,%rdi
je     1654 <getP6+0x504>
lea    0x0(,%rdi,8),%r9
add    %rbp,%r9
lea    (%rsi,%rdi,8),%r10
lea    (%r11,%rdi,8),%r11
lea    (%r8,%rdi,8),%r8
mov    0x10(%rsp),%rax
lea    (%rax,%rdi,8),%rax
mov    0x60(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
lea    (%r14,%rdi,8),%rdx
mov    %r15,%rsi
sub    %rdi,%rsi
xor    %edi,%edi
movsd  0x1add(%rip),%xmm8
movsd  0x1adc(%rip),%xmm9
movsd  0x1adb(%rip),%xmm10
movsd  0x1ada(%rip),%xmm11
movsd  0x1ad9(%rip),%xmm12
movsd  0x1ad8(%rip),%xmm13
movsd  0x1ad7(%rip),%xmm14
movsd  0x1ad6(%rip),%xmm15
movsd  0x1ad6(%rip),%xmm0
movsd  0x1ad6(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rdi,8),%xmm2
mulsd  %xmm2,%xmm2
movsd  (%rcx,%rdi,8),%xmm4
movapd %xmm4,%xmm6
mulsd  %xmm4,%xmm6
movapd %xmm2,%xmm5
mulsd  %xmm8,%xmm5
movapd %xmm4,%xmm3
mulsd  %xmm9,%xmm3
addsd  %xmm5,%xmm3
subsd  %xmm4,%xmm5
movsd  %xmm5,(%rax,%rdi,8)
movsd  %xmm3,(%r8,%rdi,8)
movapd %xmm2,%xmm3
mulsd  %xmm10,%xmm3
movapd %xmm2,%xmm5
mulsd  %xmm11,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm5
addsd  %xmm6,%xmm5
movsd  %xmm5,(%r11,%rdi,8)
movapd %xmm2,%xmm5
mulsd  %xmm12,%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm3,%xmm5
movapd %xmm2,%xmm3
mulsd  %xmm14,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm2,%xmm7
mulsd  %xmm15,%xmm7
mulsd  %xmm2,%xmm7
mulsd  %xmm4,%xmm7
mulsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm2
mulsd  %xmm1,%xmm4
mulsd  %xmm6,%xmm4
mulsd  %xmm13,%xmm6
addsd  %xmm5,%xmm6
movsd  %xmm6,(%r10,%rdi,8)
addsd  %xmm7,%xmm3
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm4
movsd  %xmm4,(%r9,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1580 <getP6+0x430>
test   %ebx,%ebx
jle    1c32 <getP6+0xae2>
mov    0x1a0(%rsp),%r13
mov    0x68(%rsp),%rax
lea    (%rax,%rax,4),%r8d
lea    0x0(,%rax,4),%edi
lea    (%rax,%rax,1),%ecx
lea    (%rax,%rax,2),%edx
lea    -0x1(%r15),%rbp
mov    %rbp,0x140(%rsp)
mov    %r15d,%ebp
and    $0xfffffffe,%ebp
mov    %rbp,0x120(%rsp)
mov    %eax,%r9d
xor    %esi,%esi
movsd  0x19b6(%rip),%xmm10
movsd  0x19b5(%rip),%xmm12
movsd  0x19b4(%rip),%xmm13
movsd  0x19b3(%rip),%xmm14
movsd  0x19b3(%rip),%xmm2
movsd  0x19b3(%rip),%xmm3
mov    %r8,0x148(%rsp)
mov    %rdi,0x138(%rsp)
mov    %rcx,0x130(%rsp)
mov    %rcx,%rbp
mov    %rdx,0x128(%rsp)
mov    %rdx,%r10
mov    %r13,%r11
mov    0xe0(%rsp),%rcx
jmp    1768 <getP6+0x618>
mov    0x150(%rsp),%rsi
add    $0x1,%rsi
mov    0x80(%rsp),%rax
mov    0xc0(%rsp),%rcx
add    %rax,%rcx
mov    0xc8(%rsp),%r11
add    %rax,%r11
mov    0x20(%rsp),%r9
add    %r15,%r9
mov    0xd0(%rsp),%r10
add    %r15,%r10
mov    0xd8(%rsp),%rbp
add    %r15,%rbp
mov    0x50(%rsp),%rdi
add    %r15,%rdi
mov    0x18(%rsp),%r8
add    %r15,%r8
cmp    %r15,%rsi
mov    0x190(%rsp),%ebx
je     1c32 <getP6+0xae2>
mov    %rcx,0xc0(%rsp)
movsd  (%r14,%rsi,8),%xmm15
mov    0x40(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm9
mulsd  %xmm10,%xmm9
mov    0x30(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm8
mulsd  %xmm12,%xmm8
mov    0x10(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm11
mulsd  %xmm13,%xmm11
mov    0x38(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm6
mulsd  %xmm14,%xmm6
mov    0x28(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm7
cmp    $0x2,%ebx
movapd %xmm7,0xf0(%rsp)
mov    %r9,0x20(%rsp)
mov    %rsi,0x150(%rsp)
mov    %r8,0x18(%rsp)
mov    %rdi,0x50(%rsp)
mov    %rbp,0xd8(%rsp)
mov    %r10,0xd0(%rsp)
mov    %r11,0xc8(%rsp)
jae    1990 <getP6+0x840>
xor    %ebp,%ebp
mov    0x28(%rsp),%rax
lea    (%rax,%rbp,8),%r12
mov    0x38(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0xb0(%rsp)
mov    0x10(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0xa0(%rsp)
mov    0x30(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0x90(%rsp)
mov    0x40(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0x58(%rsp)
lea    (%r14,%rbp,8),%r8
mov    0xc0(%rsp),%rax
lea    (%rax,%rbp,8),%rdi
mov    0xc8(%rsp),%rax
lea    (%rax,%rbp,8),%rsi
mov    0x20(%rsp),%rax
lea    (%rax,%rbp,1),%eax
mov    0xd0(%rsp),%rcx
add    %ebp,%ecx
mov    0xd8(%rsp),%rdx
add    %ebp,%edx
mov    0x50(%rsp),%rbx
lea    (%rbx,%rbp,1),%r11d
mov    0x18(%rsp),%rbx
lea    (%rbx,%rbp,1),%r10d
mov    %r15,%r9
sub    %rbp,%r9
xor    %ebp,%ebp
xchg   %ax,%ax
mov    0x58(%rsp),%rbx
movsd  (%rbx,%rbp,8),%xmm4
mulsd  %xmm9,%xmm4
lea    (%rdx,%rbp,1),%ebx
movslq %ebx,%rbx
mulsd  0x0(%r13,%rbx,8),%xmm4
lea    (%r11,%rbp,1),%ebx
movslq %ebx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm5
lea    (%r10,%rbp,1),%ebx
movslq %ebx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm0
mov    0xa0(%rsp),%rbx
movsd  (%rbx,%rbp,8),%xmm7
mulsd  %xmm11,%xmm7
lea    (%rcx,%rbp,1),%ebx
movslq %ebx,%rbx
mulsd  0x0(%r13,%rbx,8),%xmm7
mov    0xb0(%rsp),%rbx
movsd  (%rbx,%rbp,8),%xmm1
mulsd  %xmm6,%xmm1
lea    (%rax,%rbp,1),%ebx
movslq %ebx,%rbx
mulsd  0x0(%r13,%rbx,8),%xmm1
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
mov    0x90(%rsp),%rbx
movsd  (%rbx,%rbp,8),%xmm4
mulsd  %xmm8,%xmm4
mulsd  (%rsi,%rbp,8),%xmm4
addsd  %xmm5,%xmm4
movsd  (%r8,%rbp,8),%xmm5
mulsd  %xmm15,%xmm5
mulsd  %xmm5,%xmm4
mulsd  %xmm3,%xmm0
addsd  %xmm4,%xmm0
addsd  %xmm0,%xmm7
addsd  %xmm7,%xmm1
movsd  (%r12,%rbp,8),%xmm0
mulsd  0xf0(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r9
jne    18a0 <getP6+0x750>
jmp    1700 <getP6+0x5b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %esi,%eax
imul   %r15d,%eax
mov    0x148(%rsp),%rcx
add    %eax,%ecx
mov    0x140(%rsp),%rbx
lea    (%rcx,%rbx,1),%edx
cmp    %ecx,%edx
jl     1800 <getP6+0x6b0>
mov    %rbx,%rcx
shr    $0x20,%rcx
jne    1800 <getP6+0x6b0>
mov    0x138(%rsp),%rdx
add    %eax,%edx
lea    (%rdx,%rbx,1),%esi
cmp    %edx,%esi
jl     1800 <getP6+0x6b0>
test   %rcx,%rcx
jne    1800 <getP6+0x6b0>
mov    0x130(%rsp),%rdx
add    %eax,%edx
lea    (%rdx,%rbx,1),%esi
cmp    %edx,%esi
jl     1800 <getP6+0x6b0>
test   %rcx,%rcx
jne    1800 <getP6+0x6b0>
mov    0x128(%rsp),%rdx
add    %eax,%edx
lea    (%rdx,%rbx,1),%esi
cmp    %edx,%esi
jl     1800 <getP6+0x6b0>
test   %rcx,%rcx
jne    1800 <getP6+0x6b0>
movapd %xmm15,0x90(%rsp)
add    0x68(%rsp),%eax
lea    (%rax,%rbx,1),%edx
cmp    %eax,%edx
jl     1c21 <getP6+0xad1>
mov    $0x0,%ebp
test   %rcx,%rcx
movapd 0x90(%rsp),%xmm15
jne    1802 <getP6+0x6b2>
unpcklpd %xmm15,%xmm15
movapd %xmm15,0xb0(%rsp)
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
movapd %xmm0,0xa0(%rsp)
movapd %xmm8,%xmm10
unpcklpd %xmm8,%xmm10
movapd %xmm11,%xmm1
unpcklpd %xmm11,%xmm1
movapd %xmm6,%xmm2
unpcklpd %xmm6,%xmm2
unpcklpd %xmm7,%xmm7
xor    %eax,%eax
mov    0x28(%rsp),%r11
mov    0x10(%rsp),%rbx
mov    0x120(%rsp),%rdx
mov    0x20(%rsp),%rsi
movapd 0x1692(%rip),%xmm3
mov    0x18(%rsp),%rdi
mov    0x50(%rsp),%rbp
mov    %r14,%r12
mov    0xd8(%rsp),%r14
mov    0xd0(%rsp),%r8
mov    0xc8(%rsp),%r9
mov    0xc0(%rsp),%r10
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rax,1),%ecx
movslq %ecx,%rcx
movupd 0x0(%r13,%rcx,8),%xmm12
lea    (%rax,%rbp,1),%ecx
movslq %ecx,%rcx
movupd 0x0(%r13,%rcx,8),%xmm13
lea    (%r14,%rax,1),%ecx
movslq %ecx,%rcx
movupd 0x0(%r13,%rcx,8),%xmm14
lea    (%r8,%rax,1),%ecx
movslq %ecx,%rcx
movupd 0x0(%r13,%rcx,8),%xmm15
lea    (%rsi,%rax,1),%ecx
movslq %ecx,%rcx
movupd 0x0(%r13,%rcx,8),%xmm4
mov    0x40(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm5
mulpd  0xa0(%rsp),%xmm5
mulpd  %xmm5,%xmm14
mulpd  0x15ec(%rip),%xmm13
addpd  %xmm14,%xmm13
mov    0x30(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm5
mulpd  %xmm10,%xmm5
movupd (%r9,%rax,8),%xmm0
mulpd  %xmm5,%xmm0
addpd  %xmm13,%xmm0
movupd (%r12,%rax,8),%xmm5
mulpd  0xb0(%rsp),%xmm5
mulpd  %xmm5,%xmm0
mulpd  %xmm3,%xmm12
addpd  %xmm0,%xmm12
movupd (%rbx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
mulpd  %xmm0,%xmm15
addpd  %xmm12,%xmm15
mov    0x38(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
mulpd  %xmm0,%xmm4
addpd  %xmm15,%xmm4
movupd (%r11,%rax,8),%xmm0
mulpd  %xmm7,%xmm0
addpd  %xmm4,%xmm0
movupd %xmm0,(%r10,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1ae0 <getP6+0x990>
mov    %rdx,%rbp
cmp    %r15,%rdx
movsd  0x147a(%rip),%xmm10
movsd  0x1479(%rip),%xmm12
movsd  0x1478(%rip),%xmm13
movsd  0x1477(%rip),%xmm14
movsd  0x1477(%rip),%xmm2
movsd  0x1477(%rip),%xmm3
mov    %r12,%r14
movapd 0x90(%rsp),%xmm15
je     1700 <getP6+0x5b0>
jmp    1802 <getP6+0x6b2>
xor    %ebp,%ebp
movapd 0x90(%rsp),%xmm15
jmp    1802 <getP6+0x6b2>
mov    0x198(%rsp),%eax
test   %eax,%eax
mov    0x10(%rsp),%r9
jle    2077 <getP6+0xf27>
imul   0x68(%rsp),%eax
mov    %rax,0x90(%rsp)
xor    %eax,%eax
xor    %ecx,%ecx
mov    %rcx,0x18(%rsp)
mov    0x60(%rsp),%rbp
jmp    1c99 <getP6+0xb49>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x18(%rsp),%rdx
add    $0x1,%rdx
mov    0x50(%rsp),%rax
add    0x90(%rsp),%rax
mov    %rdx,%rcx
mov    %rdx,0x18(%rsp)
cmp    0x8(%rsp),%rdx
je     1dbe <getP6+0xc6e>
mov    %rax,0x50(%rsp)
mov    %rax,0x58(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
jmp    1cde <getP6+0xb8e>
nopl   0x0(%rax)
mov    0x20(%rsp),%rcx
add    $0x1,%rcx
mov    0x58(%rsp),%rax
add    0x68(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
cmp    0x8(%rsp),%rcx
mov    0x190(%rsp),%ebx
je     1c70 <getP6+0xb20>
test   %ebx,%ebx
jle    1cb0 <getP6+0xb60>
mov    0xe8(%rsp),%rax
mov    0x18(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movapd 0x1454(%rip),%xmm0
xorpd  %xmm0,%xmm2
mov    0x20(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorpd  %xmm0,%xmm3
mov    0x58(%rsp),%r13
mov    0xe0(%rsp),%r14
xor    %ebx,%ebx
movapd %xmm2,0xb0(%rsp)
movapd %xmm3,0xa0(%rsp)
nop
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%r12,8),%xmm0
movsd  %xmm0,0xf0(%rsp)
movsd  0x0(%rbp,%r12,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <exp@plt>
movapd 0xa0(%rsp),%xmm3
movapd 0xb0(%rsp),%xmm2
mulsd  0xf0(%rsp),%xmm0
lea    (%r12,%r13,1),%eax
cltq
mov    0x48(%rsp),%rsi
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%r12
cmp    %r12,%r15
jne    1d40 <getP6+0xbf0>
add    $0x1,%rbx
add    0x80(%rsp),%r14
add    %r15,%r13
cmp    %r15,%rbx
jne    1d30 <getP6+0xbe0>
jmp    1cb0 <getP6+0xb60>
mov    0x198(%rsp),%eax
test   %eax,%eax
mov    0x10(%rsp),%r9
jle    2077 <getP6+0xf27>
mov    0x108(%rsp),%rax
add    %eax,%eax
lea    (%rax,%rax,2),%eax
cltq
mov    %rax,0xa0(%rsp)
lea    -0x1(%r15),%rcx
mov    %r15d,%edx
and    $0x3,%edx
mov    %r15d,%esi
and    $0xfffffffc,%esi
mov    0x48(%rsp),%rax
lea    0x18(%rax),%rdi
xor    %r9d,%r9d
movsd  0x127b(%rip),%xmm0
jmp    1e24 <getP6+0xcd4>
nop
mov    0x60(%rsp),%r9
add    $0x1,%r9
cmp    0x8(%rsp),%r9
je     1ff3 <getP6+0xea3>
mov    %r9,%r8
imul   0x78(%rsp),%r8
mov    0xa0(%rsp),%rax
mov    %r8,%rbp
mov    %r8,0x80(%rsp)
add    %r8,%rax
mov    %rax,0xf0(%rsp)
mov    %r9,0x60(%rsp)
mov    %r9,%r13
jmp    1e8d <getP6+0xd3d>
cs nopw 0x0(%rax,%rax,1)
nop
mulsd  %xmm0,%xmm1
mov    0xb0(%rsp),%r13
mov    0x80(%rsp),%rax
add    %r13,%rax
mov    0x70(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%r13
cmp    0x8(%rsp),%r13
je     1e10 <getP6+0xcc0>
mov    %r13,0xb0(%rsp)
imul   0x78(%rsp),%r13
add    0xa0(%rsp),%r13
xorpd  %xmm1,%xmm1
xor    %r8d,%r8d
xor    %r9d,%r9d
jmp    1ec6 <getP6+0xd76>
nop
add    $0x1,%r9
mov    %r12,%r8
add    0x90(%rsp),%r8d
cmp    0x8(%rsp),%r9
je     1e60 <getP6+0xd10>
mov    0xf0(%rsp),%rax
add    %r9,%rax
mov    0x100(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm2
mov    0x88(%rsp),%rax
movsd  (%rax,%r9,8),%xmm3
mov    %r8,%r12
mov    %r8d,%r14d
xor    %r11d,%r11d
jmp    1f44 <getP6+0xdf4>
nopl   0x0(%rax,%rax,1)
lea    (%r11,%r13,1),%rax
mov    0x100(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm5
mov    0x88(%rsp),%rax
mulsd  (%rax,%r11,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm5,%xmm1
add    $0x1,%r11
add    0x68(%rsp),%r14d
cmp    0x8(%rsp),%r11
je     1eb0 <getP6+0xd60>
xorpd  %xmm4,%xmm4
test   %ebx,%ebx
jle    1f00 <getP6+0xdb0>
mov    %r14d,%r10d
xor    %ebp,%ebp
jmp    1f73 <getP6+0xe23>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbp
mov    0x190(%rsp),%ebx
add    %ebx,%r10d
cmp    %r15,%rbp
je     1f00 <getP6+0xdb0>
movslq %r10d,%rax
cmp    $0x3,%rcx
jae    1f90 <getP6+0xe40>
xor    %r8d,%r8d
jmp    1fc4 <getP6+0xe74>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rax,8),%rbx
xor    %r8d,%r8d
nopw   0x0(%rax,%rax,1)
addsd  -0x18(%rbx,%r8,8),%xmm4
addsd  -0x10(%rbx,%r8,8),%xmm4
addsd  -0x8(%rbx,%r8,8),%xmm4
addsd  (%rbx,%r8,8),%xmm4
add    $0x4,%r8
cmp    %r8,%rsi
jne    1fa0 <getP6+0xe50>
test   %rdx,%rdx
je     1f60 <getP6+0xe10>
add    %rax,%r8
mov    0x48(%rsp),%rax
lea    (%rax,%r8,8),%rax
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
addsd  (%rax,%rbx,8),%xmm4
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1fe0 <getP6+0xe90>
jmp    1f60 <getP6+0xe10>
mov    0x198(%rsp),%eax
test   %eax,%eax
mov    0x110(%rsp),%rcx
mov    0x10(%rsp),%r9
jle    2077 <getP6+0xf27>
mov    0x78(%rsp),%rax
mov    0x70(%rsp),%rdi
lea    (%rdi,%rax,8),%rbx
lea    0x8(,%rax,8),%r8
xor    %edx,%edx
mov    0x8(%rsp),%rsi
jmp    2041 <getP6+0xef1>
nopw   0x0(%rax,%rax,1)
add    %r8,%rbx
add    %r8,%rdi
add    $0xffffffffffffffff,%rsi
cmp    0x8(%rsp),%rdx
je     2077 <getP6+0xf27>
add    $0x1,%rdx
cmp    0x78(%rsp),%rdx
jge    2030 <getP6+0xee0>
mov    $0x1,%ebp
mov    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rbp,8),%xmm0
movsd  %xmm0,(%rax)
add    %rcx,%rax
add    $0x1,%rbp
cmp    %rbp,%rsi
jne    2060 <getP6+0xf10>
jmp    2030 <getP6+0xee0>
mov    0x88(%rsp),%rdi
mov    %r9,%rbx
call   1030 <free@plt>
mov    0xe8(%rsp),%rdi
call   1030 <free@plt>
mov    0xe0(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rax
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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