double *getP9(double *x, double *y, double *z, double *r2, double *alphas,
              double *betas, int Asize, int Nsize, double *ReX) {
  double *P9 = (double *)malloc(Nsize * Nsize * sizeof(double));
  if (Asize == 0) {
    for (int n = 0; n < Nsize * Nsize; n++) {
      P9[n] = 0.0;
    }
    return P9;
  }
  double sumsInner = 0;
  double sumsOuter = 0;
  double oneO1Palpha;
  double oneO1PalphaSqrt;
  double z2 = 0, z4 = 0, z6 = 0, z8 = 0;
  double r4 = 0, r6 = 0, r8 = 0;
  double *alphaO1Palpha = (double *)malloc(Nsize * sizeof(double));
  double *oneO1PalphaSqrt21 = (double *)malloc(Nsize * sizeof(double));
  double *ReXStripe = (double *)malloc(Asize * Asize * sizeof(double));
  double *zr17 = (double *)malloc(Asize * sizeof(double));
  double *zr173 = (double *)malloc(Asize * sizeof(double));
  double *zr85 = (double *)malloc(Asize * sizeof(double));
  double *zr1710 = (double *)malloc(Asize * sizeof(double));
  double *zr2211 = (double *)malloc(Asize * sizeof(double));
  double *zr2212 = (double *)malloc(Asize * sizeof(double));
  double *zr2431 = (double *)malloc(Asize * sizeof(double));
  double *zr12155 = (double *)malloc(Asize * sizeof(double));
  double *kkdij =
      (double *)malloc(Nsize * Nsize * Asize * Asize * sizeof(double));
  for (int n = 0; n < Nsize; n++) {
    oneO1Palpha = 1.0 / (1.0 + alphas[9 * Nsize + n]);
    oneO1PalphaSqrt = sqrt(oneO1Palpha);
    oneO1PalphaSqrt21[n] = oneO1PalphaSqrt * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha;
    alphaO1Palpha[n] = alphas[9 * Nsize + n] * oneO1Palpha;
  }
  for (int i = 0; i < Asize; i++) {
    z2 = z[i] * z[i];
    z4 = z2 * z2;
    z6 = z2 * z4;
    z8 = z4 * z4;
    r4 = r2[i] * r2[i];
    r6 = r4 * r2[i];
    r8 = r4 * r4;
    zr17[i] = 17.0 * z2 - r2[i];
    zr173[i] = 17.0 * z2 - 3.0 * r2[i];
    zr85[i] = 85 * z4 - 30 * z2 * r2[i] + r4;
    zr1710[i] = 17 * z4 - 10 * z2 * r2[i] + r4;
    zr2211[i] = 221 * z6 - 195 * z4 * r2[i] + 39 * z2 * r4 - r6;
    zr2212[i] = 221 * z6 - 273 * z4 * r2[i] + 91 * z2 * r4 - 7 * r6;
    zr2431[i] =
        2431 * z8 - 4004 * z6 * r2[i] + 2002 * z4 * r4 - 308 * z2 * r6 + 7 * r8;
    zr12155[i] = 12155 * z8 - 25740 * z6 * r2[i] + 18018 * z4 * r4 -
                 4620 * z2 * r6 + 315 * r8;
  }
  for (int i = 0; i < Asize; i++) {
    for (int j = 0; j < Asize; j++) {
      ReXStripe[i * Asize + j] =
          z[i] * z[j] *
              (109395 * ReX[7 * Asize * Asize + i * Asize + j] +
               17160 * zr173[i] * zr173[j] *
                   ReX[5 * Asize * Asize + i * Asize + j] +
               180180 * zr1710[i] * zr1710[j] *
                   ReX[3 * Asize * Asize + i * Asize + j] +
               3960 * zr2212[i] * zr2212[j] *
                   ReX[Asize * Asize + i * Asize + j] +
               zr12155[i] * zr12155[j]) +
          6077.5 * ReX[8 * Asize * Asize + i * Asize + j] +
          3217.5 * zr17[i] * zr17[j] * ReX[6 * Asize * Asize + i * Asize + j] +
          2574 * zr85[i] * zr85[j] * ReX[4 * Asize * Asize + i * Asize + j] +
          2310 * zr2211[i] * zr2211[j] *
              ReX[2 * Asize * Asize + i * Asize + j] +
          45 * zr2431[i] * zr2431[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[9 * Nsize * Nsize + n * Nsize + k] *
                       betas[9 * Nsize * Nsize + nd * Nsize + kd] *
                       oneO1PalphaSqrt21[k] * oneO1PalphaSqrt21[kd] * sumsInner;
        }
      }
      P9[Nsize * n + nd] =
          19.0 * 9.86960440108936 * 1.52587890625e-05 * sumsOuter;
    }
  }
  for (int n = 0; n < Nsize; n++) {
    for (int nd = n + 1; nd < Nsize; nd++) {
      P9[Nsize * nd + n] = P9[Nsize * n + nd];
    }
  }
  free(oneO1PalphaSqrt21);
  free(alphaO1Palpha);
  free(ReXStripe);
  free(zr17);
  free(zr173);
  free(zr85);
  free(zr1710);
  free(zr2211);
  free(zr2212);
  free(zr2431);
  free(zr12155);
  free(kkdij);
  return P9;
}


x86 assembly (clang, -O0):
<getP9>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%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 <getP9+0x92>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    11c5 <getP9+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 <getP9+0x55>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    21cd <getP9+0x108d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xb0(%rbp)
mov    0x10(%rbp),%eax
imul   0x10(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xd0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xd8(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xe0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xe8(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xf0(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xf8(%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,-0x100(%rbp)
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    140d <getP9+0x2cd>
mov    -0x30(%rbp),%rax
imul   $0x9,0x18(%rbp),%ecx
add    -0x104(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1d9c(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  0x1d8f(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
imul   $0x9,0x18(%rbp),%ecx
add    -0x104(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    1334 <getP9+0x1f4>
movl   $0x0,-0x108(%rbp)
mov    -0x108(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    18ff <getP9+0x7bf>
mov    -0x20(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x1bc1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  0x1bae(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x1b6a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movsd  0x1b5a(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x1b1e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x90(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movsd  0x1ae6(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x1aaa(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x90(%rbp),%xmm0
ff
mov    -0xd8(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm1
movsd  0x1a72(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1a26(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1a26(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x98(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
movsd  0x19e1(%rip),%xmm1
mulsd  -0x78(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x19a5(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x198d(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x1960(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm1
ff
movsd  0x192d(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x18f1(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x18d9(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x18b4(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm2
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x1870(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm1
ff
movsd  0x183d(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x108(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1801(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x17e9(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x17c4(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm2
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x1780(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x108(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x108(%rbp)
jmp    1417 <getP9+0x2d7>
movl   $0x0,-0x10c(%rbp)
mov    -0x10c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1cae <getP9+0xb6e>
movl   $0x0,-0x110(%rbp)
mov    -0x110(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1c95 <getP9+0xb55>
mov    -0x20(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x110(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
imul   $0x7,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x10c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x110(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xc8(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  0x16bb(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
mov    -0xc8(%rbp),%rax
movslq -0x110(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
imul   $0x5,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x10c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x110(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
movsd  0x166d(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  0x1647(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
mov    -0xd8(%rbp),%rax
movslq -0x110(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
imul   $0x3,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x10c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x110(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0xe8(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  0x15e3(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0xe8(%rbp),%rax
movslq -0x110(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x10c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x110(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0xf8(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x3,%ecx
imul   0x10(%rbp),%ecx
mov    -0x10c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x110(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x153d(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  0x1512(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x110(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
imul   $0x6,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x10c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x110(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xd0(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  0x14ae(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x110(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x2,%ecx
imul   0x10(%rbp),%ecx
mov    -0x10c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x110(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  0x1448(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0xe0(%rbp),%rax
movslq -0x110(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   0x10(%rbp),%ecx
mov    -0x10c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x110(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  0x13e2(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x110(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x10c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x110(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
mov    -0x10c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x110(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x110(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x110(%rbp)
jmp    1922 <getP9+0x7e2>
jmp    1c9a <getP9+0xb5a>
mov    -0x10c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10c(%rbp)
jmp    1909 <getP9+0x7c9>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1e6b <getP9+0xd2b>
movl   $0x0,-0x118(%rbp)
mov    -0x118(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1e52 <getP9+0xd12>
movl   $0x0,-0x11c(%rbp)
mov    -0x11c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1e39 <getP9+0xcf9>
movl   $0x0,-0x120(%rbp)
mov    -0x120(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1e20 <getP9+0xce0>
mov    -0xb8(%rbp),%rax
mov    -0x11c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x120(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0xa8(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x11c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xa8(%rbp),%rax
movslq -0x118(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x120(%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  -0x148(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x100(%rbp),%rax
mov    -0x114(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x118(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x11c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x120(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    1d03 <getP9+0xbc3>
jmp    1e25 <getP9+0xce5>
mov    -0x11c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11c(%rbp)
jmp    1cea <getP9+0xbaa>
jmp    1e3e <getP9+0xcfe>
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    1cd1 <getP9+0xb91>
jmp    1e57 <getP9+0xd17>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    1cb8 <getP9+0xb78>
movl   $0x0,-0x124(%rbp)
mov    -0x124(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    2099 <getP9+0xf59>
mov    -0x124(%rbp),%eax
mov    %eax,-0x128(%rbp)
mov    -0x128(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    2080 <getP9+0xf40>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    2043 <getP9+0xf03>
movl   $0x0,-0x130(%rbp)
mov    -0x130(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    202a <getP9+0xeea>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1f8d <getP9+0xe4d>
movl   $0x0,-0x138(%rbp)
mov    -0x138(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1f74 <getP9+0xe34>
mov    -0x100(%rbp),%rax
mov    -0x12c(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x130(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x134(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x138(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    1f04 <getP9+0xdc4>
jmp    1f79 <getP9+0xe39>
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1eeb <getP9+0xdab>
mov    -0x38(%rbp),%rax
imul   $0x9,0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
mov    -0x124(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0x12c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
imul   $0x9,0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
mov    -0x128(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0x130(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x12c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x130(%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    -0x130(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x130(%rbp)
jmp    1eca <getP9+0xd8a>
jmp    202f <getP9+0xeef>
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    1eb1 <getP9+0xd71>
movsd  0xfb5(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x124(%rbp),%ecx
add    -0x128(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    1e90 <getP9+0xd50>
jmp    2085 <getP9+0xf45>
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    1e75 <getP9+0xd35>
movl   $0x0,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    2135 <getP9+0xff5>
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x140(%rbp)
mov    -0x140(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    211c <getP9+0xfdc>
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x13c(%rbp),%ecx
add    -0x140(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x140(%rbp),%ecx
add    -0x13c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x140(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x140(%rbp)
jmp    20c1 <getP9+0xf81>
jmp    2121 <getP9+0xfe1>
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    20a3 <getP9+0xf63>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x100(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getP9>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x258,%rsp
mov    %r9,0x168(%rsp)
mov    %r8,%rbp
mov    %rcx,0x60(%rsp)
mov    %rdx,0x58(%rsp)
mov    0x298(%rsp),%r15d
mov    0x290(%rsp),%r14d
mov    %r15d,%r13d
imul   %r13d,%r13d
lea    0x0(,%r13,8),%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0xb8(%rsp)
test   %r14d,%r14d
je     13a5 <getP9+0x255>
mov    %rbp,0x40(%rsp)
movslq %r15d,%rax
mov    %rax,0xc0(%rsp)
lea    0x0(,%rax,8),%rbp
mov    %rbp,%rdi
mov    %r14d,%ebx
call   1050 <malloc@plt>
mov    %rax,0x128(%rsp)
mov    %rbp,0x1e8(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0xd0(%rsp)
mov    %r14d,%r12d
imul   %r12d,%r12d
lea    0x0(,%r12,8),%rdi
call   1050 <malloc@plt>
mov    %rax,0x120(%rsp)
movslq %r14d,%rbp
shl    $0x3,%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %rbp,0xc8(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %r12,0x68(%rsp)
mov    %r12d,%eax
mov    %r13,0x1e0(%rsp)
imul   %r13d,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %r15d,%eax
mov    %rax,(%rsp)
test   %r15d,%r15d
jle    137a <getP9+0x22a>
mov    0x298(%rsp),%eax
lea    (%rax,%rax,8),%eax
cltq
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,8),%r15
xor    %r13d,%r13d
movsd  0x1d2b(%rip),%xmm1
xorpd  %xmm2,%xmm2
jmp    1355 <getP9+0x205>
xchg   %ax,%ax
movapd %xmm3,%xmm0
movsd  %xmm3,0x40(%rsp)
call   1070 <sqrt@plt>
movsd  0x40(%rsp),%xmm3
xorpd  %xmm2,%xmm2
movsd  0x1cff(%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
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mov    0xd0(%rsp),%rax
movsd  %xmm0,(%rax,%r13,8)
mulsd  (%r15,%r13,8),%xmm3
mov    0x128(%rsp),%rax
movsd  %xmm3,(%rax,%r13,8)
add    $0x1,%r13
cmp    %r13,(%rsp)
je     137a <getP9+0x22a>
movsd  (%r15,%r13,8),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
divsd  %xmm0,%xmm3
ucomisd %xmm2,%xmm3
jb     12e0 <getP9+0x190>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1301 <getP9+0x1b1>
mov    0x290(%rsp),%edi
mov    %edi,%r13d
test   %edi,%edi
mov    %r14,0xb0(%rsp)
mov    0x58(%rsp),%r11
jle    2228 <getP9+0x10d8>
cmp    $0x1,%edi
jne    13c5 <getP9+0x275>
xor    %eax,%eax
jmp    1616 <getP9+0x4c6>
test   %r13d,%r13d
je     2747 <getP9+0x15f7>
mov    0xb8(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
jmp    2747 <getP9+0x15f7>
mov    %r13d,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
movapd 0x1d2a(%rip),%xmm8
movapd 0x1e31(%rip),%xmm9
movapd 0x1e38(%rip),%xmm10
movapd 0x1e3f(%rip),%xmm11
movapd 0x1e46(%rip),%xmm12
mov    0x38(%rsp),%r8
mov    0x30(%rsp),%r9
mov    0x28(%rsp),%r10
mov    0x20(%rsp),%rbp
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%rsi
mov    0x60(%rsp),%rdi
mov    0x8(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%r11,%rcx,8),%xmm5
mulpd  %xmm5,%xmm5
movapd %xmm5,%xmm4
mulpd  %xmm5,%xmm4
movapd %xmm5,%xmm7
mulpd  %xmm4,%xmm7
movupd (%rdi,%rcx,8),%xmm3
movapd %xmm5,%xmm1
mulpd  %xmm8,%xmm1
movapd %xmm3,%xmm2
mulpd  0x1cac(%rip),%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm3,%xmm1
movupd %xmm1,(%rbx,%rcx,8)
movupd %xmm2,(%r14,%rcx,8)
movapd %xmm5,%xmm1
mulpd  0x1c9d(%rip),%xmm1
mulpd  %xmm3,%xmm1
movapd %xmm4,%xmm6
mulpd  0x1c9d(%rip),%xmm6
addpd  %xmm1,%xmm6
movapd %xmm5,%xmm1
mulpd  0x1c9d(%rip),%xmm1
mulpd  %xmm3,%xmm1
movapd %xmm4,%xmm0
mulpd  0x1c9d(%rip),%xmm0
mulpd  %xmm3,%xmm0
movapd %xmm4,%xmm14
mulpd  0x1cbb(%rip),%xmm14
mulpd  %xmm3,%xmm14
movapd %xmm3,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm2,%xmm6
movupd %xmm6,(%r8,%rcx,8)
movapd %xmm4,%xmm6
mulpd  %xmm8,%xmm6
addpd  %xmm1,%xmm6
addpd  %xmm2,%xmm6
movupd %xmm6,(%r9,%rcx,8)
movapd %xmm7,%xmm6
mulpd  0x1c61(%rip),%xmm6
addpd  %xmm6,%xmm0
movapd %xmm5,%xmm13
mulpd  0x1c5f(%rip),%xmm13
mulpd  %xmm2,%xmm13
addpd  %xmm0,%xmm13
movapd %xmm7,%xmm15
mulpd  0x1c87(%rip),%xmm15
mulpd  %xmm3,%xmm15
mulpd  0x1cca(%rip),%xmm7
mulpd  %xmm3,%xmm7
mulpd  %xmm2,%xmm3
subpd  %xmm3,%xmm13
movupd %xmm13,(%r10,%rcx,8)
addpd  %xmm6,%xmm14
movapd %xmm5,%xmm0
mulpd  0x1c36(%rip),%xmm0
mulpd  %xmm2,%xmm0
addpd  %xmm14,%xmm0
movapd %xmm5,%xmm1
mulpd  0x1c71(%rip),%xmm1
mulpd  %xmm3,%xmm1
mulpd  %xmm11,%xmm5
mulpd  %xmm3,%xmm5
mulpd  0x1c1c(%rip),%xmm3
addpd  %xmm0,%xmm3
movapd %xmm4,%xmm0
mulpd  %xmm4,%xmm0
movupd %xmm3,0x0(%rbp,%rcx,8)
movapd %xmm0,%xmm3
mulpd  0x1c1e(%rip),%xmm3
addpd  %xmm15,%xmm3
movapd %xmm4,%xmm6
mulpd  0x1c1d(%rip),%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm10,%xmm4
mulpd  %xmm2,%xmm4
mulpd  %xmm2,%xmm2
addpd  %xmm6,%xmm1
movapd %xmm2,%xmm3
mulpd  0x1c18(%rip),%xmm3
addpd  %xmm1,%xmm3
movupd %xmm3,(%rdx,%rcx,8)
mulpd  %xmm9,%xmm0
addpd  %xmm7,%xmm0
addpd  %xmm0,%xmm4
addpd  %xmm4,%xmm5
mulpd  %xmm12,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm2,(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1430 <getP9+0x2e0>
cmp    %r13,%rax
je     189c <getP9+0x74c>
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%r10
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%r9
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x40(%rsp)
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%r11
mov    0x30(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x38(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
lea    (%r14,%rax,8),%rsi
mov    0x8(%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
mov    0x60(%rsp),%rbp
lea    0x0(%rbp,%rax,8),%r8
mov    %r9,%rbp
mov    0x58(%rsp),%rbx
lea    (%rbx,%rax,8),%r9
mov    %r10,%rbx
mov    %r13,%r10
sub    %rax,%r10
xor    %eax,%eax
movsd  0x1980(%rip),%xmm8
movsd  0x19ff(%rip),%xmm9
movsd  0x19fe(%rip),%xmm10
movsd  0x19fd(%rip),%xmm11
movsd  0x19fc(%rip),%xmm12
mov    0x40(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rax,8),%xmm5
mulsd  %xmm5,%xmm5
movapd %xmm5,%xmm4
mulsd  %xmm5,%xmm4
movapd %xmm5,%xmm7
mulsd  %xmm4,%xmm7
movsd  (%r8,%rax,8),%xmm3
movapd %xmm5,%xmm1
mulsd  %xmm8,%xmm1
movapd %xmm3,%xmm2
mulsd  0x191b(%rip),%xmm2
addsd  %xmm1,%xmm2
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  %xmm2,(%rsi,%rax,8)
movapd %xmm5,%xmm1
mulsd  0x1905(%rip),%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm4,%xmm6
mulsd  0x18fd(%rip),%xmm6
addsd  %xmm1,%xmm6
movapd %xmm5,%xmm1
mulsd  0x18f5(%rip),%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm4,%xmm0
mulsd  0x18ed(%rip),%xmm0
mulsd  %xmm3,%xmm0
movapd %xmm4,%xmm14
mulsd  0x18f3(%rip),%xmm14
mulsd  %xmm3,%xmm14
movapd %xmm3,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm2,%xmm6
movsd  %xmm6,(%rdx,%rax,8)
movapd %xmm4,%xmm6
mulsd  %xmm8,%xmm6
addsd  %xmm1,%xmm6
addsd  %xmm2,%xmm6
movsd  %xmm6,(%rcx,%rax,8)
movapd %xmm7,%xmm6
mulsd  0x18ab(%rip),%xmm6
addsd  %xmm6,%xmm0
movapd %xmm5,%xmm13
mulsd  0x18a1(%rip),%xmm13
mulsd  %xmm2,%xmm13
addsd  %xmm0,%xmm13
movapd %xmm7,%xmm15
mulsd  0x18a9(%rip),%xmm15
mulsd  %xmm3,%xmm15
mulsd  0x18c4(%rip),%xmm7
mulsd  %xmm3,%xmm7
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm13
movsd  %xmm13,(%r11,%rax,8)
addsd  %xmm6,%xmm14
movapd %xmm5,%xmm0
mulsd  0x1868(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm14,%xmm0
movapd %xmm5,%xmm1
mulsd  0x187b(%rip),%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm11,%xmm5
mulsd  %xmm3,%xmm5
mulsd  0x1846(%rip),%xmm3
addsd  %xmm0,%xmm3
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm3,(%r15,%rax,8)
movapd %xmm0,%xmm3
mulsd  0x1838(%rip),%xmm3
addsd  %xmm15,%xmm3
movapd %xmm4,%xmm6
mulsd  0x182f(%rip),%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm10,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm2,%xmm2
addsd  %xmm6,%xmm1
movapd %xmm2,%xmm3
mulsd  0x181a(%rip),%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x0(%rbp,%rax,8)
mulsd  %xmm9,%xmm0
addsd  %xmm7,%xmm0
addsd  %xmm0,%xmm4
addsd  %xmm4,%xmm5
mulsd  %xmm12,%xmm2
addsd  %xmm5,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    16c0 <getP9+0x570>
mov    0x290(%rsp),%edi
test   %edi,%edi
jle    2228 <getP9+0x10d8>
mov    0x2a0(%rsp),%rax
mov    0x68(%rsp),%rcx
lea    0x0(,%rcx,8),%esi
mov    %esi,%edx
sub    %ecx,%edx
lea    (%rcx,%rcx,4),%r9d
lea    (%rcx,%rcx,2),%r11d
lea    (%rcx,%rcx,1),%r15d
lea    (%r15,%r15,2),%ebx
lea    0x0(,%rcx,4),%ebp
mov    %rbp,0x160(%rsp)
lea    -0x1(%r13),%r8
mov    %r8,0x220(%rsp)
mov    %r13d,%r8d
and    $0xfffffffe,%r8d
mov    %r8,0x1f0(%rsp)
mov    %ecx,%r8d
xor    %r10d,%r10d
movsd  0x17ac(%rip),%xmm13
movsd  0x17ab(%rip),%xmm14
movsd  0x17aa(%rip),%xmm15
movsd  0x17c1(%rip),%xmm12
mov    %rdx,0x228(%rsp)
mov    %r9,0x218(%rsp)
mov    %r11,0x210(%rsp)
mov    %rsi,0x208(%rsp)
mov    %rbx,0x200(%rsp)
mov    0x160(%rsp),%rbp
mov    %r15,0x1f8(%rsp)
mov    %r15,%rcx
mov    %rax,0xa8(%rsp)
mov    0x120(%rsp),%r15
mov    %r15,0xd8(%rsp)
mov    0x58(%rsp),%r15
jmp    1a27 <getP9+0x8d7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x230(%rsp),%r10
add    $0x1,%r10
mov    0xc8(%rsp),%rcx
add    %rcx,0xd8(%rsp)
add    %rcx,%rbp
mov    %rbp,0xa8(%rsp)
mov    0xe0(%rsp),%rcx
add    %r13,%rcx
mov    0xe8(%rsp),%rbp
add    %r13,%rbp
mov    0xf0(%rsp),%rbx
add    %r13,%rbx
mov    0xf8(%rsp),%rsi
add    %r13,%rsi
mov    0x118(%rsp),%r8
add    %r13,%r8
mov    0x100(%rsp),%r11
add    %r13,%r11
mov    0x108(%rsp),%r9
add    %r13,%r9
mov    0x110(%rsp),%rdx
add    %r13,%rdx
cmp    %r13,%r10
mov    0xb0(%rsp),%r14
mov    0x290(%rsp),%edi
je     2228 <getP9+0x10d8>
mov    %rcx,0xe0(%rsp)
mov    %rbp,0xe8(%rsp)
mov    %rbx,0xf0(%rsp)
mov    %rsi,0xf8(%rsp)
mov    %rdx,0x110(%rsp)
mov    %r8,0x118(%rsp)
movsd  (%r15,%r10,8),%xmm0
movsd  (%r14,%r10,8),%xmm1
mulsd  0x1645(%rip),%xmm1
mov    0x30(%rsp),%rcx
movsd  (%rcx,%r10,8),%xmm3
mulsd  %xmm13,%xmm3
mov    0x20(%rsp),%rcx
movsd  (%rcx,%r10,8),%xmm4
mulsd  %xmm14,%xmm4
mov    0x10(%rsp),%rcx
movsd  (%rcx,%r10,8),%xmm2
mov    0x8(%rsp),%r14
movsd  (%r14,%r10,8),%xmm8
mulsd  %xmm15,%xmm8
mov    0x38(%rsp),%rcx
movsd  (%rcx,%r10,8),%xmm9
mulsd  0x1616(%rip),%xmm9
mov    0x28(%rsp),%rcx
movsd  (%rcx,%r10,8),%xmm10
mulsd  0x160a(%rip),%xmm10
mov    0x18(%rsp),%rcx
movsd  (%rcx,%r10,8),%xmm11
mulsd  0x15fe(%rip),%xmm11
cmp    $0x2,%edi
movapd %xmm0,0x180(%rsp)
movapd %xmm1,0x40(%rsp)
movapd %xmm3,0x140(%rsp)
movapd %xmm4,0x130(%rsp)
movapd %xmm2,0x170(%rsp)
mov    %r10,0x230(%rsp)
mov    %r9,0x108(%rsp)
mov    %r11,0x100(%rsp)
jae    1b40 <getP9+0x9f0>
xor    %r8d,%r8d
mov    0xa8(%rsp),%rbp
jmp    1f50 <getP9+0xe00>
nopl   0x0(%rax)
mov    %r10d,%ecx
imul   %r13d,%ecx
mov    0x228(%rsp),%rdx
add    %ecx,%edx
mov    0x220(%rsp),%r8
lea    (%rdx,%r8,1),%esi
cmp    %edx,%esi
mov    0xa8(%rsp),%rbp
jl     1f3e <getP9+0xdee>
mov    %r8,%rdx
shr    $0x20,%rdx
jne    1f3e <getP9+0xdee>
mov    0x218(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%r8,1),%edi
cmp    %esi,%edi
jl     1f3e <getP9+0xdee>
test   %rdx,%rdx
jne    1f3e <getP9+0xdee>
mov    0x210(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%r8,1),%edi
cmp    %esi,%edi
jl     1f3e <getP9+0xdee>
test   %rdx,%rdx
jne    1f3e <getP9+0xdee>
mov    0x68(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%r8,1),%edi
cmp    %esi,%edi
jl     1f3e <getP9+0xdee>
test   %rdx,%rdx
jne    1f3e <getP9+0xdee>
mov    0x208(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%r8,1),%edi
cmp    %esi,%edi
jl     1f3e <getP9+0xdee>
test   %rdx,%rdx
jne    1f3e <getP9+0xdee>
mov    0x200(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%r8,1),%edi
cmp    %esi,%edi
jl     1f3e <getP9+0xdee>
test   %rdx,%rdx
jne    1f3e <getP9+0xdee>
mov    0x160(%rsp),%rsi
add    %ecx,%esi
lea    (%rsi,%r8,1),%edi
cmp    %esi,%edi
jl     1f3e <getP9+0xdee>
test   %rdx,%rdx
jne    1f3e <getP9+0xdee>
add    0x1f8(%rsp),%ecx
lea    (%rcx,%r8,1),%esi
cmp    %ecx,%esi
jl     1f43 <getP9+0xdf3>
mov    $0x0,%r8d
test   %rdx,%rdx
movsd  0x1492(%rip),%xmm12
jne    1f50 <getP9+0xe00>
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x70(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,0x90(%rsp)
unpcklpd %xmm3,%xmm3
movapd %xmm3,0x80(%rsp)
unpcklpd %xmm4,%xmm4
movapd %xmm4,0x150(%rsp)
movapd %xmm9,%xmm1
unpcklpd %xmm2,%xmm2
movapd %xmm2,0x1d0(%rsp)
movapd %xmm10,%xmm9
movapd %xmm8,0x1c0(%rsp)
unpcklpd %xmm8,%xmm8
movapd %xmm1,0x1b0(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm11,%xmm10
movapd %xmm1,%xmm11
movapd %xmm9,0x1a0(%rsp)
unpcklpd %xmm9,%xmm9
movapd %xmm10,0x190(%rsp)
unpcklpd %xmm10,%xmm10
xor    %ecx,%ecx
mov    0x1f0(%rsp),%r11
movapd 0x1556(%rip),%xmm5
movapd 0x155e(%rip),%xmm6
mov    0x110(%rsp),%r8
mov    0x108(%rsp),%r9
mov    0x100(%rsp),%r15
mov    0xf8(%rsp),%r10
mov    %rbp,%rbx
mov    0xf0(%rsp),%rbp
mov    0xe8(%rsp),%rsi
mov    0xe0(%rsp),%rdi
mov    0xd8(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r8,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm14
lea    (%r9,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm15
lea    (%r15,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm2
mov    0x118(%rsp),%rdx
add    %ecx,%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm7
lea    (%r10,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm0
lea    0x0(%rbp,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm1
lea    (%rsi,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm3
lea    (%rdi,%rcx,1),%edx
movslq %edx,%rdx
movupd (%rax,%rdx,8),%xmm13
mov    0xb0(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm12
mulpd  0x90(%rsp),%xmm12
mulpd  %xmm12,%xmm15
mulpd  %xmm5,%xmm14
addpd  %xmm15,%xmm14
mov    0x30(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm4
mulpd  0x80(%rsp),%xmm4
mulpd  %xmm4,%xmm2
addpd  %xmm14,%xmm2
mov    0x20(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm4
mulpd  0x150(%rsp),%xmm4
mulpd  %xmm4,%xmm7
addpd  %xmm2,%xmm7
mov    0x10(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm2
mulpd  0x1d0(%rsp),%xmm2
addpd  %xmm7,%xmm2
mov    0x58(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm4
mulpd  0x70(%rsp),%xmm4
mulpd  %xmm4,%xmm2
mulpd  %xmm6,%xmm0
addpd  %xmm2,%xmm0
mov    0x8(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm2
mulpd  %xmm8,%xmm2
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
mov    0x38(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm0
mulpd  %xmm11,%xmm0
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mov    0x28(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm0
mulpd  %xmm9,%xmm0
mulpd  %xmm0,%xmm13
addpd  %xmm3,%xmm13
mov    0x18(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm0
mulpd  %xmm10,%xmm0
movupd (%rbx,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm13,%xmm1
movupd %xmm1,(%r14,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r11
jne    1d50 <getP9+0xc00>
mov    %r11,%r8
cmp    %r13,%r11
mov    0x8(%rsp),%r14
mov    0x58(%rsp),%r15
movsd  0x11e0(%rip),%xmm13
movsd  0x11df(%rip),%xmm14
movsd  0x11de(%rip),%xmm15
movsd  0x11f5(%rip),%xmm12
mov    %rbx,%rbp
movapd 0x40(%rsp),%xmm1
movapd 0x140(%rsp),%xmm3
movapd 0x130(%rsp),%xmm4
movapd 0x1c0(%rsp),%xmm8
movapd 0x1b0(%rsp),%xmm9
movapd 0x1a0(%rsp),%xmm10
movapd 0x190(%rsp),%xmm11
je     1990 <getP9+0x840>
jmp    1f50 <getP9+0xe00>
xor    %r8d,%r8d
jmp    1f50 <getP9+0xe00>
xor    %r8d,%r8d
movsd  0x1199(%rip),%xmm12
nop
lea    0x0(,%r8,8),%rcx
add    %rbp,%rcx
mov    %rcx,0x70(%rsp)
mov    0xd8(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    %rcx,0x90(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    %rcx,0x80(%rsp)
mov    0x28(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    %rcx,0x150(%rsp)
mov    0x38(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    %rcx,0x1d0(%rsp)
lea    (%r14,%r8,8),%rcx
mov    %rcx,0x1c0(%rsp)
mov    0x10(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    %rcx,0x1b0(%rsp)
mov    0x20(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    %rcx,0x1a0(%rsp)
mov    0x30(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    %rcx,0x190(%rsp)
mov    0xb0(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    %rcx,0x250(%rsp)
lea    (%r15,%r8,8),%rcx
mov    %rcx,0x248(%rsp)
mov    0xe0(%rsp),%rcx
add    %r8d,%ecx
mov    %rcx,0x240(%rsp)
mov    0xe8(%rsp),%rcx
add    %r8d,%ecx
mov    %rcx,0x238(%rsp)
mov    %r13,%rdx
sub    %r8,%rdx
mov    0xf0(%rsp),%rcx
lea    (%rcx,%r8,1),%esi
mov    0xf8(%rsp),%rcx
lea    (%rcx,%r8,1),%r9d
mov    0x118(%rsp),%rcx
lea    (%rcx,%r8,1),%r11d
mov    0x100(%rsp),%rcx
add    %r8d,%ecx
mov    0x108(%rsp),%rdi
add    %r8d,%edi
mov    0x110(%rsp),%rbp
add    %ebp,%r8d
mov    0xa8(%rsp),%rbp
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x250(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm0
mulsd  %xmm1,%xmm0
lea    (%rdi,%r10,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm0
lea    (%r8,%r10,1),%ebx
movslq %ebx,%rbx
movsd  (%rax,%rbx,8),%xmm2
mov    0x190(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm7
mulsd  %xmm3,%xmm7
lea    (%rcx,%r10,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm7
mov    0x1a0(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm3
mulsd  %xmm4,%xmm3
lea    (%r11,%r10,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm3
mov    0x1c0(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm1
mulsd  %xmm8,%xmm1
lea    (%rsi,%r10,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm1
mov    0x1d0(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm4
mulsd  %xmm9,%xmm4
mov    0x238(%rsp),%rbx
lea    (%rbx,%r10,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm4
mov    0x150(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm5
mulsd  %xmm10,%xmm5
mov    0x240(%rsp),%rbx
lea    (%rbx,%r10,1),%ebx
movslq %ebx,%rbx
mulsd  (%rax,%rbx,8),%xmm5
lea    (%r9,%r10,1),%ebx
movslq %ebx,%rbx
movsd  (%rax,%rbx,8),%xmm6
mulsd  %xmm12,%xmm2
addsd  %xmm0,%xmm2
addsd  %xmm2,%xmm7
addsd  %xmm7,%xmm3
mov    0x1b0(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm0
mulsd  0x170(%rsp),%xmm0
addsd  %xmm3,%xmm0
movapd 0x140(%rsp),%xmm3
mov    0x248(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm2
mulsd  0x180(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mulsd  0xf29(%rip),%xmm6
addsd  %xmm0,%xmm6
addsd  %xmm6,%xmm1
addsd  %xmm1,%xmm4
movapd 0x40(%rsp),%xmm1
addsd  %xmm4,%xmm5
movapd 0x130(%rsp),%xmm4
mov    0x80(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm0
mulsd  %xmm11,%xmm0
mov    0x70(%rsp),%rbx
mulsd  (%rbx,%r10,8),%xmm0
addsd  %xmm5,%xmm0
mov    0x90(%rsp),%rbx
movsd  %xmm0,(%rbx,%r10,8)
add    $0x1,%r10
cmp    %r10,%rdx
jne    2090 <getP9+0xf40>
jmp    1990 <getP9+0x840>
mov    0x298(%rsp),%eax
test   %eax,%eax
mov    0x8(%rsp),%r14
jle    26c7 <getP9+0x1577>
mov    %r12,0x180(%rsp)
imul   0x68(%rsp),%eax
mov    %rax,0x170(%rsp)
xor    %eax,%eax
xor    %ecx,%ecx
mov    %rcx,0x80(%rsp)
mov    0x60(%rsp),%r12
jmp    22a1 <getP9+0x1151>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x80(%rsp),%rdx
add    $0x1,%rdx
mov    0x150(%rsp),%rax
add    0x170(%rsp),%rax
mov    %rdx,%rcx
mov    %rdx,0x80(%rsp)
cmp    (%rsp),%rdx
je     23e7 <getP9+0x1297>
mov    %rax,0x150(%rsp)
mov    %rax,0x70(%rsp)
xor    %eax,%eax
mov    %rax,0x90(%rsp)
jmp    22f7 <getP9+0x11a7>
nopw   0x0(%rax,%rax,1)
mov    0x90(%rsp),%rcx
add    $0x1,%rcx
mov    0x70(%rsp),%rax
add    0x68(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    %rcx,%rax
mov    %rcx,0x90(%rsp)
cmp    (%rsp),%rcx
mov    0x290(%rsp),%edi
je     2270 <getP9+0x1120>
test   %edi,%edi
jle    22c0 <getP9+0x1170>
mov    0x128(%rsp),%rax
mov    0x80(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movapd 0xf58(%rip),%xmm0
xorpd  %xmm0,%xmm2
mov    0x90(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorpd  %xmm0,%xmm3
mov    0x70(%rsp),%rbp
mov    0x120(%rsp),%rbx
xor    %edx,%edx
movapd %xmm2,0x140(%rsp)
movapd %xmm3,0x130(%rsp)
xchg   %ax,%ax
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%r14,8),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  (%r12,%r14,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  (%r12,%rdx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    %r13,%r15
mov    %rdx,%r13
call   1060 <exp@plt>
mov    %r13,%rdx
mov    %r15,%r13
movapd 0x130(%rsp),%xmm3
movapd 0x140(%rsp),%xmm2
mulsd  0x40(%rsp),%xmm0
lea    0x0(%rbp,%r14,1),%eax
cltq
mov    0x180(%rsp),%rsi
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%r14
cmp    %r14,%r15
jne    2360 <getP9+0x1210>
add    $0x1,%rdx
add    0xc8(%rsp),%rbx
add    %r13,%rbp
cmp    %r13,%rdx
jne    2350 <getP9+0x1200>
jmp    22c0 <getP9+0x1170>
mov    0x298(%rsp),%eax
test   %eax,%eax
mov    0x8(%rsp),%r14
mov    0x180(%rsp),%r12
jle    26c7 <getP9+0x1577>
mov    0x1e0(%rsp),%rax
lea    (%rax,%rax,8),%eax
cltq
mov    %rax,0x70(%rsp)
lea    -0x1(%r13),%rcx
mov    %r13d,%edx
and    $0x3,%edx
mov    %r13d,%esi
and    $0xfffffffc,%esi
lea    0x18(%r12),%r9
xor    %ebp,%ebp
movsd  0xcc4(%rip),%xmm0
jmp    2456 <getP9+0x1306>
cs nopw 0x0(%rax,%rax,1)
mov    0x80(%rsp),%rbp
add    $0x1,%rbp
cmp    (%rsp),%rbp
je     2644 <getP9+0x14f4>
mov    %rbp,%r8
imul   0xc0(%rsp),%r8
mov    0x70(%rsp),%rax
mov    %r8,%rbx
mov    %r8,0x90(%rsp)
add    %r8,%rax
mov    %rax,0xc8(%rsp)
mov    %rbp,0x80(%rsp)
mov    %rbp,%rbx
jmp    24bc <getP9+0x136c>
nopw   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
mov    0x90(%rsp),%rax
mov    0x60(%rsp),%rbx
add    %rbx,%rax
mov    0xb8(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rbx
cmp    (%rsp),%rbx
je     2440 <getP9+0x12f0>
mov    %rbx,0x60(%rsp)
imul   0xc0(%rsp),%rbx
add    0x70(%rsp),%rbx
mov    %rbx,0x130(%rsp)
xorpd  %xmm1,%xmm1
xor    %r8d,%r8d
xor    %eax,%eax
jmp    250f <getP9+0x13bf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x140(%rsp),%rax
add    $0x1,%rax
mov    0x40(%rsp),%r8
add    0x170(%rsp),%r8d
cmp    (%rsp),%rax
je     2490 <getP9+0x1340>
mov    0xc8(%rsp),%rbp
add    %rax,%rbp
mov    0x168(%rsp),%rbx
movsd  (%rbx,%rbp,8),%xmm2
mov    0xd0(%rsp),%rbp
mov    %rax,0x140(%rsp)
movsd  0x0(%rbp,%rax,8),%xmm3
mov    %r8,0x40(%rsp)
mov    %r8d,%r14d
xor    %r11d,%r11d
mov    0x130(%rsp),%rax
jmp    25a3 <getP9+0x1453>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rax,%r11,1),%rbp
mov    0x168(%rsp),%rbx
movsd  (%rbx,%rbp,8),%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm5
mov    0xd0(%rsp),%rbp
mulsd  0x0(%rbp,%r11,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm5,%xmm1
add    $0x1,%r11
add    0x68(%rsp),%r14d
cmp    (%rsp),%r11
je     24f0 <getP9+0x13a0>
xorpd  %xmm4,%xmm4
test   %edi,%edi
jle    2560 <getP9+0x1410>
mov    %r14d,%r10d
xor    %r15d,%r15d
jmp    25d3 <getP9+0x1483>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r15
mov    0x290(%rsp),%edi
add    %edi,%r10d
cmp    %r13,%r15
je     2560 <getP9+0x1410>
movslq %r10d,%rbx
cmp    $0x3,%rcx
jae    25e0 <getP9+0x1490>
xor    %ebp,%ebp
jmp    2614 <getP9+0x14c4>
lea    (%r9,%rbx,8),%r8
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
addsd  -0x18(%r8,%rbp,8),%xmm4
addsd  -0x10(%r8,%rbp,8),%xmm4
addsd  -0x8(%r8,%rbp,8),%xmm4
addsd  (%r8,%rbp,8),%xmm4
add    $0x4,%rbp
cmp    %rbp,%rsi
jne    25f0 <getP9+0x14a0>
test   %rdx,%rdx
je     25c0 <getP9+0x1470>
add    %rbx,%rbp
lea    (%r12,%rbp,8),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  0x0(%rbp,%rbx,8),%xmm4
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    2630 <getP9+0x14e0>
jmp    25c0 <getP9+0x1470>
mov    0x298(%rsp),%eax
test   %eax,%eax
mov    0x1e8(%rsp),%rcx
mov    0x8(%rsp),%r14
jle    26c7 <getP9+0x1577>
mov    0xb8(%rsp),%rdi
mov    0xc0(%rsp),%rax
lea    (%rdi,%rax,8),%rbx
lea    0x8(,%rax,8),%r8
xor    %edx,%edx
mov    (%rsp),%rsi
jmp    2690 <getP9+0x1540>
add    %r8,%rbx
add    %r8,%rdi
add    $0xffffffffffffffff,%rsi
cmp    (%rsp),%rdx
je     26c7 <getP9+0x1577>
add    $0x1,%rdx
cmp    0xc0(%rsp),%rdx
jge    2680 <getP9+0x1530>
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    26b0 <getP9+0x1560>
jmp    2680 <getP9+0x1530>
mov    0xd0(%rsp),%rdi
call   1030 <free@plt>
mov    0x128(%rsp),%rdi
call   1030 <free@plt>
mov    0x120(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0xb8(%rsp),%rax
add    $0x258,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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