double *getP7(double *x, double *y, double *z, double *r2, double *alphas,
              double *betas, int Asize, int Nsize, double *ReX) {
  double *P7 = (double *)malloc(Nsize * Nsize * sizeof(double));
  if (Asize == 0) {
    for (int n = 0; n < Nsize * Nsize; n++) {
      P7[n] = 0.0;
    }
    return P7;
  }
  double sumsInner = 0;
  double sumsOuter = 0;
  double oneO1Palpha;
  double oneO1PalphaSqrt;
  double z2 = 0;
  double *alphaO1Palpha = (double *)malloc(Nsize * sizeof(double));
  double *oneO1PalphaSqrt17 = (double *)malloc(Nsize * sizeof(double));
  double *ReXStripe = (double *)malloc(Asize * Asize * sizeof(double));
  double *zr13 = (double *)malloc(Asize * sizeof(double));
  double *zr133 = (double *)malloc(Asize * sizeof(double));
  double *zr1436 = (double *)malloc(Asize * sizeof(double));
  double *zr1431 = (double *)malloc(Asize * sizeof(double));
  double *zr4294 = (double *)malloc(Asize * sizeof(double));
  double *zr4296 = (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[7 * Nsize + n]);
    oneO1PalphaSqrt = sqrt(oneO1Palpha);
    oneO1PalphaSqrt17[n] = oneO1PalphaSqrt * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha * oneO1Palpha;
    alphaO1Palpha[n] = alphas[7 * Nsize + n] * oneO1Palpha;
  }
  for (int i = 0; i < Asize; i++) {
    z2 = z[i] * z[i];
    zr13[i] = 13.0 * z2 - r2[i];
    zr133[i] = 13.0 * z2 - 3.0 * r2[i];
    zr1436[i] = 143 * z2 * z2 - 66 * z2 * r2[i] + 3 * r2[i] * r2[i];
    zr1431[i] = 143 * z2 * z2 - 110 * z2 * r2[i] + 15 * r2[i] * r2[i];
    zr4294[i] = 429 * z2 * z2 * z2 - 495 * z2 * z2 * r2[i] +
                135 * z2 * r2[i] * r2[i] - 5 * r2[i] * r2[i] * r2[i];
    zr4296[i] = 429 * z2 * z2 * z2 - 693 * z2 * z2 * r2[i] +
                315 * z2 * r2[i] * r2[i] - 35 * r2[i] * r2[i] * r2[i];
  }
  for (int i = 0; i < Asize; i++) {
    for (int j = 0; j < Asize; j++) {
      ReXStripe[i * Asize + j] =
          107.25 * ReX[6 * Asize * Asize + i * Asize + j] +
          z[i] * z[j] *
              (1501.5 * ReX[5 * Asize * Asize + i * Asize + j] +
               10.5 * zr1431[i] * zr1431[j] *
                   ReX[Asize * Asize + i * Asize + j] +
               231 * zr133[i] * zr133[j] *
                   ReX[3 * Asize * Asize + i * Asize + j] +
               zr4296[i] * zr4296[j]) +
          57.75 * zr13[i] * zr13[j] * ReX[4 * Asize * Asize + i * Asize + j] +
          5.25 * zr1436[i] * zr1436[j] *
              ReX[2 * Asize * Asize + i * Asize + j] +
          1.75 * zr4294[i] * zr4294[j] * ReX[i * Asize + j];
    }
  }
  for (int k = 0; k < Nsize; k++) {
    for (int kd = 0; kd < Nsize; kd++) {
      for (int i = 0; i < Asize; i++) {
        for (int j = 0; j < Asize; j++) {
          kkdij[k * Nsize * Asize * Asize + kd * Asize * Asize + i * Asize +
                j] = ReXStripe[i * Asize + j] *
                     exp(-alphaO1Palpha[k] * r2[i] - alphaO1Palpha[kd] * r2[j]);
        }
      }
    }
  }
  for (int n = 0; n < Nsize; n++) {
    for (int nd = n; nd < Nsize; nd++) {
      sumsOuter = 0;
      for (int k = 0; k < Nsize; k++) {
        for (int kd = 0; kd < Nsize; kd++) {
          sumsInner = 0;
          for (int i = 0; i < Asize; i++) {
            for (int j = 0; j < Asize; j++) {
              sumsInner += kkdij[k * Nsize * Asize * Asize +
                                 kd * Asize * Asize + i * Asize + j];
            }
          }
          sumsOuter += betas[7 * Nsize * Nsize + n * Nsize + k] *
                       betas[7 * Nsize * Nsize + nd * Nsize + kd] *
                       oneO1PalphaSqrt17[k] * oneO1PalphaSqrt17[kd] * sumsInner;
        }
      }
      P7[Nsize * n + nd] = 15.0 * 9.86960440108936 * 9.765625e-4 * sumsOuter;
    }
  }
  for (int n = 0; n < Nsize; n++) {
    for (int nd = n + 1; nd < Nsize; nd++) {
      P7[Nsize * nd + n] = P7[Nsize * n + nd];
    }
  }
  free(oneO1PalphaSqrt17);
  free(alphaO1Palpha);
  free(ReXStripe);
  free(zr13);
  free(zr133);
  free(zr1436);
  free(zr1431);
  free(zr4294);
  free(zr4296);
  free(kkdij);
  return P7;
}


x86 assembly (clang, -O0):
<getP7>:
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 <getP7+0x92>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    11c5 <getP7+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 <getP7+0x55>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1f89 <getP7+0xe49>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    0x10(%rbp),%eax
imul   0x10(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa8(%rbp)
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    1393 <getP7+0x253>
mov    -0x30(%rbp),%rax
imul   $0x7,0x18(%rbp),%ecx
add    -0xc4(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xdb6(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  0xda9(%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
mov    -0x80(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
imul   $0x7,0x18(%rbp),%ecx
add    -0xc4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    12ca <getP7+0x18a>
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    179b <getP7+0x65b>
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)
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  0xc9b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0xc58(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xc44(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xc09(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  0xc07(%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
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0xbb8(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xb78(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  0xb5e(%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
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0xb0f(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xab7(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  0xab8(%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  0xa6f(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0xa27(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x9c0(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  0x9a1(%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  0x958(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0x910(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%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    139d <getP7+0x25d>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1a94 <getP7+0x954>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1a7b <getP7+0x93b>
mov    0x20(%rbp),%rax
imul   $0x6,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
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),%xmm2
mov    -0xa8(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  0x7e9(%rip),%xmm3
mulsd  (%rax,%rcx,8),%xmm3
mov    -0xa8(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
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
mulsd  (%rax,%rcx,8),%xmm3
movsd  0x79c(%rip),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mov    -0x98(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  0x776(%rip),%xmm3
mulsd  (%rax,%rcx,8),%xmm3
mov    -0x98(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
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),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0xb8(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xb8(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
movsd  0x6ee(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x90(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  0x6c8(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%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),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  0x662(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0xa0(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
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
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xb0(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  0x5fc(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0xcc(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x88(%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    17be <getP7+0x67e>
jmp    1a80 <getP7+0x940>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    17a5 <getP7+0x665>
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1c4b <getP7+0xb0b>
movl   $0x0,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1c32 <getP7+0xaf2>
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1c19 <getP7+0xad9>
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1c00 <getP7+0xac0>
mov    -0x88(%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    -0x78(%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    -0x78(%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    1ae9 <getP7+0x9a9>
jmp    1c05 <getP7+0xac5>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    1ad0 <getP7+0x990>
jmp    1c1e <getP7+0xade>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1ab7 <getP7+0x977>
jmp    1c37 <getP7+0xaf7>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1a9e <getP7+0x95e>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1e73 <getP7+0xd33>
mov    -0xe4(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1e5a <getP7+0xd1a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xec(%rbp)
mov    -0xec(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1e1d <getP7+0xcdd>
movl   $0x0,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1e04 <getP7+0xcc4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1d6d <getP7+0xc2d>
movl   $0x0,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1d54 <getP7+0xc14>
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    1ce4 <getP7+0xba4>
jmp    1d59 <getP7+0xc19>
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    1ccb <getP7+0xb8b>
mov    -0x38(%rbp),%rax
imul   $0x7,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   $0x7,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    -0x80(%rbp),%rax
movslq -0xec(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%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    1caa <getP7+0xb6a>
jmp    1e09 <getP7+0xcc9>
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    1c91 <getP7+0xb51>
movsd  0x1db(%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    1c70 <getP7+0xb30>
jmp    1e5f <getP7+0xd1f>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1c55 <getP7+0xb15>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1f0f <getP7+0xdcf>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1ef6 <getP7+0xdb6>
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    1e9b <getP7+0xd5b>
jmp    1efb <getP7+0xdbb>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    1e7d <getP7+0xd3d>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -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):
<getP7>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
mov    %r9,0x148(%rsp)
mov    %r8,%r12
mov    %rcx,0x48(%rsp)
mov    %rdx,0x118(%rsp)
mov    0x1e8(%rsp),%r15d
mov    0x1e0(%rsp),%r14d
mov    %r15d,%ebx
imul   %ebx,%ebx
lea    0x0(,%rbx,8),%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x78(%rsp)
test   %r14d,%r14d
je     1397 <getP7+0x247>
mov    %r12,0x10(%rsp)
movslq %r15d,%rax
mov    %rax,0x80(%rsp)
lea    0x0(,%rax,8),%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x128(%rsp)
mov    %rbp,0x158(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    %r14d,%r13d
imul   %r13d,%r13d
lea    0x0(,%r13,8),%rdi
call   1050 <malloc@plt>
mov    %rax,0x120(%rsp)
movslq %r14d,%r14
shl    $0x3,%r14
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %r14,0x50(%rsp)
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %r13,0x58(%rsp)
mov    %r13d,%eax
mov    %rbx,0x150(%rsp)
imul   %ebx,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %r15d,%eax
mov    %rax,(%rsp)
test   %r15d,%r15d
mov    0x118(%rsp),%r14
jle    1360 <getP7+0x210>
mov    0x1e8(%rsp),%eax
mov    %rax,%rcx
lea    0x0(,%rax,8),%eax
sub    %ecx,%eax
cltq
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%r15
xor    %ebx,%ebx
movsd  0x1d3d(%rip),%xmm1
xorpd  %xmm2,%xmm2
jmp    133b <getP7+0x1eb>
nopl   0x0(%rax)
movapd %xmm3,%xmm0
movsd  %xmm3,0x10(%rsp)
call   1070 <sqrt@plt>
movsd  0x10(%rsp),%xmm3
xorpd  %xmm2,%xmm2
movsd  0x1d0f(%rip),%xmm1
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    0x88(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
mulsd  (%r15,%rbx,8),%xmm3
mov    0x128(%rsp),%rax
movsd  %xmm3,(%rax,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,(%rsp)
je     1360 <getP7+0x210>
movsd  (%r15,%rbx,8),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
divsd  %xmm0,%xmm3
ucomisd %xmm2,%xmm3
jb     12d0 <getP7+0x180>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    12f1 <getP7+0x1a1>
mov    %r13,0x10(%rsp)
mov    0x1e0(%rsp),%ebx
mov    %ebx,%r13d
test   %ebx,%ebx
mov    0x40(%rsp),%r15
mov    0x18(%rsp),%rdi
mov    %r12,0x38(%rsp)
jle    1e9a <getP7+0xd4a>
cmp    $0x1,%ebx
jne    13b3 <getP7+0x263>
xor    %ebp,%ebp
mov    0x48(%rsp),%rbx
jmp    158d <getP7+0x43d>
test   %ebx,%ebx
je     2370 <getP7+0x1220>
mov    0x78(%rsp),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
jmp    2370 <getP7+0x1220>
mov    %r13d,%ebp
and    $0xfffffffe,%ebp
xor    %eax,%eax
movapd 0x1d3c(%rip),%xmm12
movapd 0x1d43(%rip),%xmm13
movapd 0x1d4a(%rip),%xmm14
movapd 0x1d51(%rip),%xmm15
movapd 0x1d58(%rip),%xmm9
movapd 0x1d5f(%rip),%xmm10
movapd 0x1d67(%rip),%xmm2
movapd 0x1d6f(%rip),%xmm3
movapd 0x1d77(%rip),%xmm4
movapd 0x1d7f(%rip),%xmm5
mov    0x30(%rsp),%rcx
mov    0x28(%rsp),%rdx
mov    0x20(%rsp),%rsi
mov    0x48(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%r14,%rax,8),%xmm6
mulpd  %xmm6,%xmm6
movupd (%rbx,%rax,8),%xmm11
movapd %xmm6,%xmm0
mulpd  0x1c74(%rip),%xmm0
movapd %xmm11,%xmm1
mulpd  0x1c77(%rip),%xmm1
addpd  %xmm0,%xmm1
subpd  %xmm11,%xmm0
movupd %xmm0,(%r12,%rax,8)
movupd %xmm1,(%r15,%rax,8)
movapd %xmm6,%xmm0
mulpd  0x1c66(%rip),%xmm0
movapd %xmm6,%xmm1
mulpd  0x1c6a(%rip),%xmm1
mulpd  %xmm11,%xmm1
mulpd  %xmm6,%xmm0
addpd  %xmm0,%xmm1
movapd %xmm11,%xmm7
mulpd  %xmm12,%xmm7
mulpd  %xmm11,%xmm7
addpd  %xmm1,%xmm7
movupd %xmm7,(%rdi,%rax,8)
movapd %xmm6,%xmm1
mulpd  %xmm13,%xmm1
mulpd  %xmm11,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm11,%xmm0
mulpd  %xmm14,%xmm0
mulpd  %xmm11,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%rcx,%rax,8)
movapd %xmm6,%xmm8
mulpd  %xmm15,%xmm8
mulpd  %xmm6,%xmm8
movapd %xmm6,%xmm0
mulpd  %xmm9,%xmm0
mulpd  %xmm6,%xmm0
mulpd  %xmm11,%xmm0
mulpd  %xmm6,%xmm8
addpd  %xmm8,%xmm0
movapd %xmm6,%xmm1
mulpd  %xmm10,%xmm1
mulpd  %xmm11,%xmm1
mulpd  %xmm11,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm11,%xmm0
mulpd  %xmm2,%xmm0
mulpd  %xmm11,%xmm0
mulpd  %xmm11,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%rdx,%rax,8)
movapd %xmm6,%xmm0
mulpd  %xmm3,%xmm0
mulpd  %xmm6,%xmm0
mulpd  %xmm11,%xmm0
addpd  %xmm8,%xmm0
mulpd  %xmm4,%xmm6
mulpd  %xmm11,%xmm6
mulpd  %xmm11,%xmm6
addpd  %xmm0,%xmm6
movapd %xmm11,%xmm0
mulpd  %xmm5,%xmm0
mulpd  %xmm11,%xmm0
mulpd  %xmm11,%xmm0
addpd  %xmm6,%xmm0
movupd %xmm0,(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1430 <getP7+0x2e0>
cmp    %r13,%rbp
je     1788 <getP7+0x638>
mov    0x20(%rsp),%rax
lea    (%rax,%rbp,8),%rsi
mov    0x28(%rsp),%rax
lea    (%rax,%rbp,8),%r10
mov    0x30(%rsp),%rax
lea    (%rax,%rbp,8),%r11
mov    0x18(%rsp),%rax
lea    (%rax,%rbp,8),%rdi
lea    (%r15,%rbp,8),%rax
lea    (%r12,%rbp,8),%rcx
lea    (%rbx,%rbp,8),%rdx
mov    %rsi,%rbx
lea    (%r14,%rbp,8),%rsi
mov    %r13,%r8
sub    %rbp,%r8
xor    %r9d,%r9d
movsd  0x1a52(%rip),%xmm12
movsd  0x1a51(%rip),%xmm13
movsd  0x1a50(%rip),%xmm14
movsd  0x1a4f(%rip),%xmm15
movsd  0x1a4e(%rip),%xmm9
movsd  0x1a4d(%rip),%xmm10
movsd  0x1a4d(%rip),%xmm2
movsd  0x1a4d(%rip),%xmm3
movsd  0x1a4d(%rip),%xmm4
movsd  0x1a4d(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%r9,8),%xmm6
mulsd  %xmm6,%xmm6
movsd  (%rdx,%r9,8),%xmm11
movapd %xmm6,%xmm0
mulsd  0x19bc(%rip),%xmm0
movapd %xmm11,%xmm1
mulsd  0x19b7(%rip),%xmm1
addsd  %xmm0,%xmm1
subsd  %xmm11,%xmm0
movsd  %xmm0,(%rcx,%r9,8)
movsd  %xmm1,(%rax,%r9,8)
movapd %xmm6,%xmm0
mulsd  0x199e(%rip),%xmm0
movapd %xmm6,%xmm1
mulsd  0x199a(%rip),%xmm1
mulsd  %xmm11,%xmm1
mulsd  %xmm6,%xmm0
addsd  %xmm0,%xmm1
movapd %xmm11,%xmm7
mulsd  %xmm12,%xmm7
mulsd  %xmm11,%xmm7
addsd  %xmm1,%xmm7
movsd  %xmm7,(%rdi,%r9,8)
movapd %xmm6,%xmm1
mulsd  %xmm13,%xmm1
mulsd  %xmm11,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm11,%xmm0
mulsd  %xmm14,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%r9,8)
movapd %xmm6,%xmm8
mulsd  %xmm15,%xmm8
mulsd  %xmm6,%xmm8
movapd %xmm6,%xmm0
mulsd  %xmm9,%xmm0
mulsd  %xmm6,%xmm0
mulsd  %xmm11,%xmm0
mulsd  %xmm6,%xmm8
addsd  %xmm8,%xmm0
movapd %xmm6,%xmm1
mulsd  %xmm10,%xmm1
mulsd  %xmm11,%xmm1
mulsd  %xmm11,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm11,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm11,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%r9,8)
movapd %xmm6,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm6,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm8,%xmm0
mulsd  %xmm4,%xmm6
mulsd  %xmm11,%xmm6
mulsd  %xmm11,%xmm6
addsd  %xmm0,%xmm6
movapd %xmm11,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm11,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm6,%xmm0
movsd  %xmm0,(%rbx,%r9,8)
add    $0x1,%r9
cmp    %r9,%r8
jne    1630 <getP7+0x4e0>
mov    0x1e0(%rsp),%ebx
test   %ebx,%ebx
mov    0x18(%rsp),%rdi
jle    1e9a <getP7+0xd4a>
mov    0x1f0(%rsp),%rax
mov    0x58(%rsp),%rcx
lea    (%rcx,%rcx,1),%edx
lea    (%rdx,%rdx,2),%r9d
lea    (%rcx,%rcx,4),%r11d
lea    (%rcx,%rcx,2),%r8d
lea    0x0(,%rcx,4),%r10d
lea    -0x1(%r13),%rsi
mov    %rsi,0x188(%rsp)
mov    %r13d,%esi
and    $0xfffffffe,%esi
mov    %rsi,0x160(%rsp)
mov    %ecx,%ebp
xor    %esi,%esi
movsd  0x18a1(%rip),%xmm12
movsd  0x18a0(%rip),%xmm15
movsd  0x18a7(%rip),%xmm8
mov    %r9,0x190(%rsp)
mov    %r11,0x180(%rsp)
mov    %r8,0x178(%rsp)
mov    %r10,0x170(%rsp)
mov    %rdx,0x168(%rsp)
mov    %rax,%rcx
mov    0x120(%rsp),%r12
mov    %r12,0xe0(%rsp)
mov    0x38(%rsp),%r12
jmp    18b9 <getP7+0x769>
xchg   %ax,%ax
mov    0x198(%rsp),%rsi
add    $0x1,%rsi
mov    0x50(%rsp),%rcx
add    %rcx,0xe0(%rsp)
mov    0xe8(%rsp),%rdx
add    %rcx,%rdx
mov    %rdx,%rcx
mov    0xf0(%rsp),%rdx
add    %r13,%rdx
mov    0xf8(%rsp),%r10
add    %r13,%r10
add    %r13,%rbx
mov    %rbx,%r8
mov    0x110(%rsp),%rbp
add    %r13,%rbp
mov    0x100(%rsp),%r11
add    %r13,%r11
mov    0x108(%rsp),%r9
add    %r13,%r9
cmp    %r13,%rsi
mov    0x18(%rsp),%rdi
mov    0x1e0(%rsp),%ebx
je     1e9a <getP7+0xd4a>
mov    %rcx,0xe8(%rsp)
mov    %rdx,0xf0(%rsp)
movsd  (%r14,%rsi,8),%xmm1
mov    0x30(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm13
mulsd  0x1795(%rip),%xmm13
movsd  (%r15,%rsi,8),%xmm14
mulsd  0x178e(%rip),%xmm14
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm10
movsd  (%r12,%rsi,8),%xmm9
mulsd  %xmm12,%xmm9
movsd  (%rdi,%rsi,8),%xmm0
mulsd  %xmm15,%xmm0
mov    0x28(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm5
mulsd  0x1774(%rip),%xmm5
cmp    $0x2,%ebx
movapd %xmm1,%xmm11
mov    %rbp,0x110(%rsp)
mov    %rsi,0x198(%rsp)
mov    %r9,0x108(%rsp)
mov    %r11,0x100(%rsp)
mov    %r10,0xf8(%rsp)
jae    1b60 <getP7+0xa10>
xor    %esi,%esi
mov    %r8,%rbx
mov    0xe8(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x8(%rsp)
mov    0xe0(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0xd0(%rsp)
mov    0x28(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0xc0(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x130(%rsp)
lea    (%r12,%rsi,8),%rcx
mov    %rcx,0x60(%rsp)
mov    0x20(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0xb0(%rsp)
lea    (%r15,%rsi,8),%rcx
mov    %rcx,0xa0(%rsp)
mov    0x30(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x90(%rsp)
lea    (%r14,%rsi,8),%rcx
mov    %rcx,0x1a0(%rsp)
mov    0xf0(%rsp),%rcx
lea    (%rcx,%rsi,1),%edx
mov    0xf8(%rsp),%rcx
lea    (%rcx,%rsi,1),%r11d
lea    (%rbx,%rsi,1),%r10d
mov    0x110(%rsp),%rcx
lea    (%rcx,%rsi,1),%r9d
mov    %r13,%rcx
sub    %rsi,%rcx
mov    0x100(%rsp),%rdi
add    %esi,%edi
mov    0x108(%rsp),%rbp
lea    (%rsi,%rbp,1),%r8d
xor    %esi,%esi
xchg   %ax,%ax
mov    0x90(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm6
mulsd  %xmm13,%xmm6
lea    (%r9,%rsi,1),%ebp
movslq %ebp,%rbp
mulsd  (%rax,%rbp,8),%xmm6
lea    (%rdi,%rsi,1),%ebp
movslq %ebp,%rbp
movsd  (%rax,%rbp,8),%xmm1
mov    0xa0(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm4
mulsd  %xmm14,%xmm4
lea    (%r10,%rsi,1),%ebp
movslq %ebp,%rbp
mulsd  (%rax,%rbp,8),%xmm4
mov    0x60(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm2
mulsd  %xmm9,%xmm2
lea    (%r11,%rsi,1),%ebp
movslq %ebp,%rbp
mulsd  (%rax,%rbp,8),%xmm2
lea    (%r8,%rsi,1),%ebp
movslq %ebp,%rbp
movsd  (%rax,%rbp,8),%xmm3
mov    0x130(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm7
mulsd  %xmm0,%xmm7
lea    (%rdx,%rsi,1),%ebp
movslq %ebp,%rbp
mulsd  (%rax,%rbp,8),%xmm7
mulsd  %xmm8,%xmm1
addsd  %xmm6,%xmm1
movapd %xmm11,%xmm6
addsd  %xmm1,%xmm4
mov    0xb0(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm4,%xmm1
mov    0x1a0(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm4
mulsd  %xmm11,%xmm4
mulsd  %xmm4,%xmm1
mulsd  0x15a2(%rip),%xmm3
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm7
mov    0xc0(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  %xmm5,%xmm1
mov    0x8(%rsp),%rbp
mulsd  0x0(%rbp,%rsi,8),%xmm1
addsd  %xmm7,%xmm1
mov    0xd0(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1a30 <getP7+0x8e0>
jmp    1840 <getP7+0x6f0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %esi,%ecx
imul   %r13d,%ecx
mov    0x190(%rsp),%rdx
add    %ecx,%edx
mov    0x188(%rsp),%rbx
lea    (%rdx,%rbx,1),%esi
cmp    %edx,%esi
jl     195a <getP7+0x80a>
mov    %rbx,%rdx
shr    $0x20,%rdx
jne    195a <getP7+0x80a>
mov    0x180(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%rbx,1),%edi
cmp    %esi,%edi
jl     195a <getP7+0x80a>
test   %rdx,%rdx
jne    195a <getP7+0x80a>
mov    0x58(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%rbx,1),%edi
cmp    %esi,%edi
jl     195a <getP7+0x80a>
test   %rdx,%rdx
jne    195a <getP7+0x80a>
mov    0x178(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%rbx,1),%edi
cmp    %esi,%edi
jl     195a <getP7+0x80a>
test   %rdx,%rdx
jne    195a <getP7+0x80a>
mov    0x170(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%rbx,1),%edi
cmp    %esi,%edi
jl     195a <getP7+0x80a>
test   %rdx,%rdx
jne    195a <getP7+0x80a>
movapd %xmm10,0x90(%rsp)
add    0x168(%rsp),%ecx
lea    (%rcx,%rbx,1),%esi
cmp    %ecx,%esi
jl     1e7d <getP7+0xd2d>
mov    $0x0,%esi
test   %rdx,%rdx
movsd  0x146e(%rip),%xmm8
mov    %r8,%rbx
movapd 0x90(%rsp),%xmm10
jne    195f <getP7+0x80f>
unpcklpd %xmm1,%xmm1
movapd %xmm1,0xd0(%rsp)
movapd %xmm13,%xmm1
unpcklpd %xmm13,%xmm1
movapd %xmm1,0xc0(%rsp)
movapd %xmm14,%xmm1
unpcklpd %xmm14,%xmm1
movapd %xmm1,0x130(%rsp)
unpcklpd %xmm10,%xmm10
movapd %xmm10,0x60(%rsp)
movapd %xmm9,%xmm1
unpcklpd %xmm9,%xmm1
movapd %xmm1,0xb0(%rsp)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm1,0xa0(%rsp)
movapd %xmm5,%xmm3
unpcklpd %xmm5,%xmm3
xor    %ecx,%ecx
mov    0x30(%rsp),%r9
mov    0x28(%rsp),%r10
mov    0x20(%rsp),%r11
mov    %rbx,0x8(%rsp)
mov    0x160(%rsp),%rbx
mov    0x110(%rsp),%rdi
movapd 0x14d2(%rip),%xmm7
mov    0x108(%rsp),%rbp
mov    0x100(%rsp),%rsi
mov    0xf8(%rsp),%r15
mov    0xf0(%rsp),%r14
mov    0xe8(%rsp),%r12
mov    0xe0(%rsp),%r8
xchg   %ax,%ax
lea    (%rcx,%rbp,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm15
lea    (%rsi,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm6
lea    (%rdi,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm8
mov    0x8(%rsp),%rdx
add    %ecx,%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm1
lea    (%r15,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm10
lea    (%r14,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm4
movupd (%r9,%rcx,8),%xmm12
mulpd  0xc0(%rsp),%xmm12
mulpd  %xmm12,%xmm8
mulpd  0x1428(%rip),%xmm6
addpd  %xmm8,%xmm6
mov    0x40(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm2
mulpd  0x130(%rsp),%xmm2
mulpd  %xmm2,%xmm1
addpd  %xmm6,%xmm1
movupd (%r11,%rcx,8),%xmm2
mulpd  0x60(%rsp),%xmm2
addpd  %xmm1,%xmm2
mov    0x118(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm1
mulpd  0xd0(%rsp),%xmm1
mulpd  %xmm1,%xmm2
mulpd  %xmm7,%xmm15
addpd  %xmm2,%xmm15
mov    0x38(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm1
mulpd  0xb0(%rsp),%xmm1
mulpd  %xmm1,%xmm10
addpd  %xmm15,%xmm10
mov    0x18(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm1
mulpd  0xa0(%rsp),%xmm1
mulpd  %xmm1,%xmm4
addpd  %xmm10,%xmm4
movupd (%r10,%rcx,8),%xmm1
mulpd  %xmm3,%xmm1
movupd (%r12,%rcx,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1d10 <getP7+0xbc0>
mov    %rbx,%rsi
cmp    %r13,%rbx
movsd  0x1249(%rip),%xmm12
movsd  0x1248(%rip),%xmm15
movsd  0x124f(%rip),%xmm8
mov    0x8(%rsp),%rbx
mov    0x38(%rsp),%r12
mov    0x118(%rsp),%r14
mov    0x40(%rsp),%r15
movapd 0x90(%rsp),%xmm10
je     1840 <getP7+0x6f0>
jmp    195f <getP7+0x80f>
xor    %esi,%esi
movsd  0x1218(%rip),%xmm8
mov    %r8,%rbx
movapd 0x90(%rsp),%xmm10
jmp    195f <getP7+0x80f>
mov    0x1e8(%rsp),%eax
test   %eax,%eax
jle    2307 <getP7+0x11b7>
imul   0x58(%rsp),%eax
mov    %rax,0x130(%rsp)
xor    %eax,%eax
xor    %ecx,%ecx
mov    %rcx,0xa0(%rsp)
mov    0x48(%rsp),%r15
jmp    1f01 <getP7+0xdb1>
nopl   0x0(%rax)
mov    0xa0(%rsp),%rdx
add    $0x1,%rdx
mov    0x90(%rsp),%rax
add    0x130(%rsp),%rax
mov    %rdx,%rcx
mov    %rdx,0xa0(%rsp)
cmp    (%rsp),%rdx
je     2030 <getP7+0xee0>
mov    %rax,0x90(%rsp)
mov    %rax,0x60(%rsp)
xor    %eax,%eax
mov    %rax,0xb0(%rsp)
jmp    1f57 <getP7+0xe07>
nopw   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rcx
add    $0x1,%rcx
mov    0x60(%rsp),%rax
add    0x58(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    %rcx,%rax
mov    %rcx,0xb0(%rsp)
cmp    (%rsp),%rcx
mov    0x1e0(%rsp),%ebx
je     1ed0 <getP7+0xd80>
test   %ebx,%ebx
jle    1f20 <getP7+0xdd0>
mov    0x128(%rsp),%rax
mov    0xa0(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movapd 0x1248(%rip),%xmm0
xorpd  %xmm0,%xmm2
mov    0xb0(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorpd  %xmm0,%xmm3
mov    0x60(%rsp),%rbp
mov    0x120(%rsp),%r14
xor    %ebx,%ebx
movapd %xmm2,0xd0(%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,0x8(%rsp)
movsd  (%r15,%r12,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  (%r15,%rbx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <exp@plt>
movapd 0xc0(%rsp),%xmm3
movapd 0xd0(%rsp),%xmm2
mulsd  0x8(%rsp),%xmm0
lea    (%r12,%rbp,1),%eax
cltq
mov    0x10(%rsp),%rsi
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%r12
cmp    %r12,%r13
jne    1fc0 <getP7+0xe70>
add    $0x1,%rbx
add    0x50(%rsp),%r14
add    %r13,%rbp
cmp    %r13,%rbx
jne    1fb0 <getP7+0xe60>
jmp    1f20 <getP7+0xdd0>
mov    0x1e8(%rsp),%eax
test   %eax,%eax
mov    0x38(%rsp),%r12
mov    0x40(%rsp),%r15
jle    2307 <getP7+0x11b7>
mov    0x150(%rsp),%rcx
lea    0x0(,%rcx,8),%eax
sub    %ecx,%eax
cltq
mov    %rax,0x50(%rsp)
lea    -0x1(%r13),%rcx
mov    %r13d,%edx
and    $0x3,%edx
mov    %r13d,%esi
and    $0xfffffffc,%esi
mov    0x10(%rsp),%rax
lea    0x18(%rax),%rdi
xor    %r9d,%r9d
movsd  0x102b(%rip),%xmm0
jmp    20a3 <getP7+0xf53>
nopw   0x0(%rax,%rax,1)
mov    0x60(%rsp),%r9
add    $0x1,%r9
cmp    (%rsp),%r9
je     2273 <getP7+0x1123>
mov    %r9,%r8
imul   0x80(%rsp),%r8
mov    0x50(%rsp),%rax
mov    %r8,%rbp
mov    %r8,0x48(%rsp)
add    %r8,%rax
mov    %rax,0xd0(%rsp)
mov    %r9,0x60(%rsp)
mov    %r9,%r12
jmp    2109 <getP7+0xfb9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
mov    0x48(%rsp),%rax
mov    0xc0(%rsp),%r12
add    %r12,%rax
mov    0x78(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%r12
cmp    (%rsp),%r12
je     2090 <getP7+0xf40>
mov    %r12,0xc0(%rsp)
imul   0x80(%rsp),%r12
add    0x50(%rsp),%r12
xorpd  %xmm1,%xmm1
xor    %r8d,%r8d
xor    %r9d,%r9d
jmp    2147 <getP7+0xff7>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
mov    0x8(%rsp),%r8
add    0x130(%rsp),%r8d
cmp    (%rsp),%r9
je     20e0 <getP7+0xf90>
mov    0xd0(%rsp),%rax
add    %r9,%rax
mov    0x148(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm2
mov    0x88(%rsp),%rax
movsd  (%rax,%r9,8),%xmm3
mov    %r8,0x8(%rsp)
mov    %r8d,%r14d
xor    %r11d,%r11d
jmp    21c3 <getP7+0x1073>
nopl   0x0(%rax,%rax,1)
lea    (%r12,%r11,1),%rax
mov    0x148(%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    0x58(%rsp),%r14d
cmp    (%rsp),%r11
je     2130 <getP7+0xfe0>
xorpd  %xmm4,%xmm4
test   %ebx,%ebx
jle    2180 <getP7+0x1030>
mov    %r14d,%r10d
xor    %r15d,%r15d
jmp    21f3 <getP7+0x10a3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r15
mov    0x1e0(%rsp),%ebx
add    %ebx,%r10d
cmp    %r13,%r15
je     2180 <getP7+0x1030>
movslq %r10d,%rbp
cmp    $0x3,%rcx
jae    2210 <getP7+0x10c0>
xor    %r8d,%r8d
jmp    2244 <getP7+0x10f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rbp,8),%rax
xor    %r8d,%r8d
nopw   0x0(%rax,%rax,1)
addsd  -0x18(%rax,%r8,8),%xmm4
addsd  -0x10(%rax,%r8,8),%xmm4
addsd  -0x8(%rax,%r8,8),%xmm4
addsd  (%rax,%r8,8),%xmm4
add    $0x4,%r8
cmp    %r8,%rsi
jne    2220 <getP7+0x10d0>
test   %rdx,%rdx
je     21e0 <getP7+0x1090>
add    %rbp,%r8
mov    0x10(%rsp),%rax
lea    (%rax,%r8,8),%rax
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
addsd  (%rax,%rbp,8),%xmm4
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    2260 <getP7+0x1110>
jmp    21e0 <getP7+0x1090>
mov    0x1e8(%rsp),%eax
test   %eax,%eax
mov    0x158(%rsp),%rcx
mov    0x38(%rsp),%r12
mov    0x40(%rsp),%r15
jle    2307 <getP7+0x11b7>
mov    0x78(%rsp),%rdi
mov    0x80(%rsp),%rax
lea    (%rdi,%rax,8),%rbx
lea    0x8(,%rax,8),%r8
xor    %edx,%edx
mov    (%rsp),%rsi
jmp    22d0 <getP7+0x1180>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %r8,%rbx
add    %r8,%rdi
add    $0xffffffffffffffff,%rsi
cmp    (%rsp),%rdx
je     2307 <getP7+0x11b7>
add    $0x1,%rdx
cmp    0x80(%rsp),%rdx
jge    22c0 <getP7+0x1170>
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    22f0 <getP7+0x11a0>
jmp    22c0 <getP7+0x1170>
mov    0x88(%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    %r15,%rdi
call   1030 <free@plt>
mov    0x18(%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    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rax
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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