#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double exp(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double sqrt(double);
double *getP3(double *x, double *y, double *z, double *r2, double *alphas,
              double *betas, int Asize, int Nsize, double *ReX) {
  double *P3 = (double *)malloc(Nsize * Nsize * sizeof(double));
  if (Asize == 0) {
    for (int n = 0; n < Nsize * Nsize; n++) {
      P3[n] = 0.0;
    }
    return P3;
  }
  double sumsInner = 0;
  double sumsOuter = 0;
  double oneO1Palpha;
  double oneO1PalphaSqrt;
  double *alphaO1Palpha = (double *)malloc(Nsize * sizeof(double));
  double *oneO1PalphaSqrt9 = (double *)malloc(Nsize * sizeof(double));
  double *ReXStripe = (double *)malloc(Asize * Asize * sizeof(double));
  double *zxy4 = (double *)malloc(Asize * sizeof(double));
  double *zxy233 = (double *)malloc(Asize * sizeof(double));
  double *kkdij =
      (double *)malloc(Nsize * Nsize * Asize * Asize * sizeof(double));
  for (int n = 0; n < Nsize; n++) {
    oneO1Palpha = 1.0 / (1.00000000 + alphas[3 * Nsize + n]);
    oneO1PalphaSqrt = sqrt(oneO1Palpha);
    oneO1PalphaSqrt9[n] =
        oneO1PalphaSqrt * oneO1Palpha * oneO1Palpha * oneO1Palpha * oneO1Palpha;
    alphaO1Palpha[n] = alphas[3 * Nsize + n] * oneO1Palpha;
  }
  for (int i = 0; i < Asize; i++) {
    zxy4[i] = (4 * z[i] * z[i] - x[i] * x[i] - y[i] * y[i]);
    zxy233[i] = (2 * z[i] * z[i] - 3 * x[i] * x[i] - 3 * y[i] * y[i]);
  }
  for (int i = 0; i < Asize; i++) {
    for (int j = 0; j < Asize; j++) {
      ReXStripe[i * Asize + j] =
          2.5 * ReX[2 * Asize * Asize + i * Asize + j] +
          z[i] * z[j] *
              (15.0 * ReX[Asize * Asize + i * Asize + j] +
               zxy233[i] * zxy233[j]) +
          1.5 * zxy4[i] * zxy4[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[3 * Nsize * Nsize + n * Nsize + k] *
                       betas[3 * Nsize * Nsize + nd * Nsize + kd] *
                       oneO1PalphaSqrt9[k] * oneO1PalphaSqrt9[kd] * sumsInner;
        }
      }
      P3[Nsize * n + nd] = 7.0 * 9.86960440108936 * 0.0625 * sumsOuter;
    }
  }
  for (int n = 0; n < Nsize; n++) {
    for (int nd = n + 1; nd < Nsize; nd++) {
      P3[Nsize * nd + n] = P3[Nsize * n + nd];
    }
  }
  free(oneO1PalphaSqrt9);
  free(alphaO1Palpha);
  free(ReXStripe);
  free(zxy4);
  free(zxy233);
  free(kkdij);
  return P3;
}


x86 assembly (clang, -O0):
<getP3>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%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
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
cmpl   $0x0,0x10(%rbp)
jne    11d3 <getP3+0x93>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    11c6 <getP3+0x86>
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    1196 <getP3+0x56>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1b21 <getP3+0x9e1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movslq 0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
movslq 0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    0x10(%rbp),%eax
imul   0x10(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
movslq 0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq 0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x90(%rbp)
mov    0x18(%rbp),%eax
imul   0x18(%rbp),%eax
imul   0x10(%rbp),%eax
imul   0x10(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    132f <getP3+0x1ef>
mov    -0x30(%rbp),%rax
imul   $0x3,0x18(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd96(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  0xd89(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
imul   $0x3,0x18(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    127a <getP3+0x13a>
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    14de <getP3+0x39e>
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  0xcd5(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  0xc14(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  0xbe4(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  0xb9d(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1339 <getP3+0x1f9>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1662 <getP3+0x522>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1649 <getP3+0x509>
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   0x10(%rbp),%ecx
mov    -0xa4(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xa8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xa4(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xa8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x90(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x90(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movsd  0xa6d(%rip),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
movsd  0xa51(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x88(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  0xa2b(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0xa4(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xa8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
mov    -0xa4(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xa8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1501 <getP3+0x3c1>
jmp    164e <getP3+0x50e>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    14e8 <getP3+0x3a8>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1816 <getP3+0x6d6>
movl   $0x0,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    17fd <getP3+0x6bd>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    17e4 <getP3+0x6a4>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    17cb <getP3+0x68b>
mov    -0x80(%rbp),%rax
mov    -0xb4(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xb8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x70(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x70(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xb8(%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  -0xe0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
mov    -0xac(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xb0(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0xb4(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xb8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    16b7 <getP3+0x577>
jmp    17d0 <getP3+0x690>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    169e <getP3+0x55e>
jmp    17e9 <getP3+0x6a9>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1685 <getP3+0x545>
jmp    1802 <getP3+0x6c2>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    166c <getP3+0x52c>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1a3e <getP3+0x8fe>
mov    -0xbc(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1a25 <getP3+0x8e5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    19e8 <getP3+0x8a8>
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    19cf <getP3+0x88f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1938 <getP3+0x7f8>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    191f <getP3+0x7df>
mov    -0x98(%rbp),%rax
mov    -0xc4(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xc8(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0xcc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    18af <getP3+0x76f>
jmp    1924 <getP3+0x7e4>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1896 <getP3+0x756>
mov    -0x38(%rbp),%rax
imul   $0x3,0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
mov    -0xbc(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0xc4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
imul   $0x3,0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
mov    -0xc0(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0xc8(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xc8(%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    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1875 <getP3+0x735>
jmp    19d4 <getP3+0x894>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    185c <getP3+0x71c>
movsd  0x610(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xbc(%rbp),%ecx
add    -0xc0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    183b <getP3+0x6fb>
jmp    1a2a <getP3+0x8ea>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1820 <getP3+0x6e0>
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1ada <getP3+0x99a>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1ac1 <getP3+0x981>
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xd4(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xd8(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1a66 <getP3+0x926>
jmp    1ac6 <getP3+0x986>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1a48 <getP3+0x908>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getP3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,0x88(%rsp)
mov    %r8,%r14
mov    %rcx,%rbx
mov    %rdx,%rbp
mov    %rsi,0x10(%rsp)
mov    %rdi,0x8(%rsp)
mov    0xd8(%rsp),%r15d
mov    0xd0(%rsp),%r13d
mov    %r15d,%r12d
imul   %r12d,%r12d
lea    0x0(,%r12,8),%edi
call   1050 <malloc@plt>
mov    %rax,0x48(%rsp)
test   %r13d,%r13d
je     1814 <getP3+0x6c4>
mov    %r14,0x18(%rsp)
mov    %rbp,0x38(%rsp)
mov    %rbx,0x78(%rsp)
lea    0x0(,%r15,8),%r14d
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %r15,%rbx
mov    %rax,%r15
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %r13d,%eax
imul   %eax,%eax
mov    %rax,0x50(%rsp)
lea    0x0(,%rax,8),%r14d
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,0x70(%rsp)
lea    0x0(,%r13,8),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x30(%rsp)
imul   %r12d,%r14d
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%eax
mov    %rax,0x58(%rsp)
test   %ebx,%ebx
jle    12e1 <getP3+0x191>
mov    0xd8(%rsp),%eax
lea    (%rax,%rax,2),%eax
cltq
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rbx
xor    %ebp,%ebp
movsd  0xda5(%rip),%xmm1
xorpd  %xmm2,%xmm2
jmp    12c1 <getP3+0x171>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm0
movsd  %xmm3,0x18(%rsp)
call   1070 <sqrt@plt>
movsd  0x18(%rsp),%xmm3
xorpd  %xmm2,%xmm2
movsd  0xd6f(%rip),%xmm1
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mov    0x60(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
mulsd  (%rbx,%rbp,8),%xmm3
movsd  %xmm3,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,0x58(%rsp)
je     12e1 <getP3+0x191>
movsd  (%rbx,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
divsd  %xmm0,%xmm3
ucomisd %xmm2,%xmm3
jb     1270 <getP3+0x120>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1291 <getP3+0x141>
mov    %r12,0x68(%rsp)
mov    %r15,0x80(%rsp)
mov    0xd0(%rsp),%eax
mov    %eax,%r12d
test   %eax,%eax
mov    %r13,0x28(%rsp)
mov    0x30(%rsp),%r11
mov    0x38(%rsp),%r15
jle    14a7 <getP3+0x357>
mov    0xd0(%rsp),%edx
cmp    $0x1,%edx
jne    190a <getP3+0x7ba>
xor    %eax,%eax
mov    0x10(%rsp),%rsi
mov    0x8(%rsp),%rdi
movsd  0xcd5(%rip),%xmm0
movsd  0xcd5(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm0,%xmm3
movsd  (%rdi,%rax,8),%xmm4
mulsd  %xmm4,%xmm4
mulsd  %xmm2,%xmm3
subsd  %xmm4,%xmm3
movsd  (%rsi,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
subsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%r13,%rax,8)
movsd  (%r15,%rax,8),%xmm2
movapd %xmm2,%xmm3
addsd  %xmm2,%xmm3
movsd  (%rdi,%rax,8),%xmm4
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm3
addsd  %xmm5,%xmm3
movsd  (%rsi,%rax,8),%xmm2
movapd %xmm2,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%r11,%rax,8)
add    $0x1,%rax
cmp    %rax,%r12
jne    1340 <getP3+0x1f0>
test   %edx,%edx
jle    14a7 <getP3+0x357>
mov    0xe0(%rsp),%r9
mov    0x50(%rsp),%rax
lea    (%rax,%rax,1),%r10d
lea    0x0(,%r12,8),%r8
mov    %eax,%esi
xor    %edi,%edi
movsd  0xc2d(%rip),%xmm0
movsd  0xc2d(%rip),%xmm1
movsd  0xc2d(%rip),%xmm2
mov    %r9,%rax
mov    0x70(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r10,%rbx,1),%ebp
movslq %ebp,%rbp
movsd  (%r15,%rdi,8),%xmm3
mulsd  (%r15,%rbx,8),%xmm3
lea    (%rsi,%rbx,1),%ecx
movslq %ecx,%rcx
movsd  (%r11,%rdi,8),%xmm4
mulsd  (%r11,%rbx,8),%xmm4
movsd  (%r9,%rcx,8),%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm3,%xmm5
movsd  (%r9,%rbp,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm5,%xmm3
movsd  0x0(%r13,%rdi,8),%xmm4
mulsd  %xmm2,%xmm4
mulsd  0x0(%r13,%rbx,8),%xmm4
mulsd  (%rax,%rbx,8),%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rdx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1420 <getP3+0x2d0>
add    $0x1,%rdi
add    %r8,%rdx
add    %r8,%rax
add    %r12,%rsi
add    %r12,%r10
cmp    %r12,%rdi
jne    1410 <getP3+0x2c0>
mov    0xd8(%rsp),%eax
test   %eax,%eax
mov    0xd0(%rsp),%ebp
jle    18b8 <getP3+0x768>
movslq %ebp,%rcx
shl    $0x3,%rcx
mov    %rcx,0x38(%rsp)
imul   0x50(%rsp),%eax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
movapd 0xb83(%rip),%xmm2
xor    %ecx,%ecx
mov    %r12,0x90(%rsp)
jmp    1507 <getP3+0x3b7>
nopl   0x0(%rax)
add    $0x1,%rcx
mov    0x40(%rsp),%rax
add    0x8(%rsp),%rax
cmp    %rbx,%rcx
je     1615 <getP3+0x4c5>
mov    %rax,0x40(%rsp)
mov    %rax,0x20(%rsp)
xor    %edx,%edx
jmp    1544 <getP3+0x3f4>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
mov    0x20(%rsp),%rax
add    0x50(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    0x58(%rsp),%rbx
cmp    %rbx,%rdx
mov    0xd0(%rsp),%ebp
je     14f0 <getP3+0x3a0>
test   %ebp,%ebp
jle    1520 <getP3+0x3d0>
mov    0x20(%rsp),%rsi
mov    0x70(%rsp),%rax
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nop
xor    %r15d,%r15d
mov    %rax,0x10(%rsp)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%r15,8),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    0x80(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x78(%rsp),%rbp
movsd  0x0(%rbp,%r15,8),%xmm1
mulsd  (%rax,%rdx,8),%xmm1
xorpd  %xmm2,%xmm0
mulsd  0x0(%rbp,%r13,8),%xmm0
subsd  %xmm1,%xmm0
mov    %rcx,%rbx
mov    %r14,%r12
mov    %rdx,%r14
mov    %rsi,%rbp
call   1060 <exp@plt>
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %r12,%r14
mov    0x90(%rsp),%r12
mov    %rbx,%rcx
movapd 0xa8a(%rip),%xmm2
mulsd  0x18(%rsp),%xmm0
lea    0x0(%rbp,%r15,1),%eax
cltq
movsd  %xmm0,(%r14,%rax,8)
mov    0x10(%rsp),%rax
add    $0x1,%r15
cmp    %r15,%r12
jne    1570 <getP3+0x420>
add    $0x1,%r13
add    0x38(%rsp),%rax
add    %r12,%rsi
cmp    %r12,%r13
jne    1560 <getP3+0x410>
jmp    1520 <getP3+0x3d0>
mov    0xd8(%rsp),%eax
test   %eax,%eax
mov    0x28(%rsp),%r13
jle    18b8 <getP3+0x768>
mov    0x68(%rsp),%rax
lea    (%rax,%rax,2),%eax
cltq
mov    %rax,0x20(%rsp)
lea    -0x1(%r12),%rcx
mov    %r12d,%edx
and    $0x3,%edx
mov    %r12d,%esi
and    $0xfffffffc,%esi
lea    0x18(%r14),%r9
xor    %r10d,%r10d
movsd  0x9d8(%rip),%xmm0
jmp    1672 <getP3+0x522>
nopw   0x0(%rax,%rax,1)
mov    0x68(%rsp),%r10
add    $0x1,%r10
cmp    %rbx,%r10
je     1835 <getP3+0x6e5>
mov    %r10,%r8
imul   %rbx,%r8
mov    0x20(%rsp),%rax
mov    %r8,%rdi
mov    %r8,0x40(%rsp)
add    %r8,%rax
mov    %rax,0x78(%rsp)
mov    %r10,0x68(%rsp)
mov    %r10,%r15
jmp    16c4 <getP3+0x574>
nopl   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
mov    0x40(%rsp),%rax
mov    0x38(%rsp),%r15
add    %r15,%rax
mov    0x48(%rsp),%rdi
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%r15
cmp    %rbx,%r15
je     1660 <getP3+0x510>
mov    %r15,0x38(%rsp)
imul   %rbx,%r15
add    0x20(%rsp),%r15
xorpd  %xmm1,%xmm1
xor    %r8d,%r8d
xor    %r10d,%r10d
jmp    16f8 <getP3+0x5a8>
xchg   %ax,%ax
mov    0x10(%rsp),%r10
add    $0x1,%r10
mov    0x18(%rsp),%r8
add    0x8(%rsp),%r8d
cmp    %rbx,%r10
je     16a0 <getP3+0x550>
mov    0x78(%rsp),%rax
add    %r10,%rax
mov    0x88(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm2
mov    0x60(%rsp),%rax
mov    %r10,0x10(%rsp)
movsd  (%rax,%r10,8),%xmm3
mov    %r8,0x18(%rsp)
mov    %r8d,%r10d
xor    %r11d,%r11d
jmp    1773 <getP3+0x623>
nopw   0x0(%rax,%rax,1)
lea    (%r15,%r11,1),%rax
mov    0x88(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm5
mov    0x60(%rsp),%rax
mulsd  (%rax,%r11,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm5,%xmm1
add    $0x1,%r11
add    0x50(%rsp),%r10d
mov    0x58(%rsp),%rbx
cmp    %rbx,%r11
je     16e0 <getP3+0x590>
xorpd  %xmm4,%xmm4
test   %ebp,%ebp
jle    1730 <getP3+0x5e0>
mov    %r10d,%ebx
xor    %eax,%eax
jmp    17a2 <getP3+0x652>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
mov    0xd0(%rsp),%ebp
add    %ebp,%ebx
cmp    %r12,%rax
je     1730 <getP3+0x5e0>
movslq %ebx,%r13
cmp    $0x3,%rcx
jae    17b0 <getP3+0x660>
xor    %r8d,%r8d
jmp    17e5 <getP3+0x695>
lea    (%r9,%r13,8),%rbp
xor    %r8d,%r8d
nopw   0x0(%rax,%rax,1)
addsd  -0x18(%rbp,%r8,8),%xmm4
addsd  -0x10(%rbp,%r8,8),%xmm4
addsd  -0x8(%rbp,%r8,8),%xmm4
addsd  0x0(%rbp,%r8,8),%xmm4
add    $0x4,%r8
cmp    %r8,%rsi
jne    17c0 <getP3+0x670>
test   %rdx,%rdx
je     1790 <getP3+0x640>
add    %r13,%r8
lea    (%r14,%r8,8),%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  0x0(%rbp,%rdi,8),%xmm4
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1800 <getP3+0x6b0>
jmp    1790 <getP3+0x640>
test   %r12d,%r12d
je     18f3 <getP3+0x7a3>
mov    %r12d,%edx
shl    $0x3,%rdx
mov    0x48(%rsp),%rdi
xor    %esi,%esi
call   1040 <memset@plt>
jmp    18f3 <getP3+0x7a3>
mov    0xd8(%rsp),%eax
test   %eax,%eax
mov    0x28(%rsp),%r13
jle    18b8 <getP3+0x768>
mov    0x48(%rsp),%rbp
lea    0x0(,%rbx,8),%rdx
add    %rbp,%rdx
lea    0x0(,%rbx,8),%rcx
lea    0x8(,%rbx,8),%r8
xor    %esi,%esi
mov    %rbx,%rdi
jmp    1884 <getP3+0x734>
nopl   0x0(%rax)
add    %r8,%rdx
add    %r8,%rbp
add    $0xffffffffffffffff,%rdi
mov    0x58(%rsp),%rbx
cmp    %rbx,%rsi
je     18b8 <getP3+0x768>
add    $0x1,%rsi
cmp    %rbx,%rsi
jae    1870 <getP3+0x720>
mov    $0x1,%ebx
mov    %rdx,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rax)
add    %rcx,%rax
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    18a0 <getP3+0x750>
jmp    1870 <getP3+0x720>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x0(,%r12,8),%rax
add    %r13,%rax
lea    (%r11,%r12,8),%rbp
lea    (%r15,%r12,8),%rsi
mov    0x8(%rsp),%rcx
lea    (%rcx,%r12,8),%rdi
cmp    %rbp,%r13
setb   0x18(%rsp)
cmp    %rax,%r11
mov    %r15,%rdx
setb   0x20(%rsp)
cmp    %rsi,%r13
setb   %r15b
cmp    %rdx,%rax
seta   0x40(%rsp)
cmp    %rdi,%r13
setb   %r10b
cmp    %rcx,%rax
seta   0x7(%rsp)
mov    0x10(%rsp),%r9
lea    (%r9,%r12,8),%rbx
cmp    %rbx,%r13
setb   %r13b
cmp    %r9,%rax
mov    %r11,%rax
seta   %r11b
cmp    %rsi,%rax
setb   %sil
cmp    %rdx,%rbp
seta   %dl
cmp    %rdi,%rax
setb   %dil
cmp    %rcx,%rbp
seta   0x6(%rsp)
cmp    %rbx,%rax
setb   %r8b
cmp    %r9,%rbp
seta   %bpl
xor    %eax,%eax
mov    0x20(%rsp),%cl
test   %cl,0x18(%rsp)
jne    1ada <getP3+0x98a>
and    0x40(%rsp),%r15b
mov    0x38(%rsp),%r15
jne    1ac4 <getP3+0x974>
and    0x7(%rsp),%r10b
jne    1ac4 <getP3+0x974>
and    %r11b,%r13b
jne    1ac4 <getP3+0x974>
and    %dl,%sil
mov    0x28(%rsp),%r13
mov    0x30(%rsp),%r11
jne    1ab8 <getP3+0x968>
and    0x6(%rsp),%dil
mov    0x10(%rsp),%rsi
jne    1aac <getP3+0x95c>
and    %bpl,%r8b
mov    0xd0(%rsp),%edx
mov    0x8(%rsp),%rdi
jne    132b <getP3+0x1db>
mov    %r12d,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
movapd 0x629(%rip),%xmm0
movapd 0x631(%rip),%xmm1
nop
movupd (%r15,%rcx,8),%xmm2
movapd %xmm2,%xmm3
mulpd  %xmm0,%xmm3
movupd (%rdi,%rcx,8),%xmm4
mulpd  %xmm4,%xmm4
mulpd  %xmm2,%xmm3
subpd  %xmm4,%xmm3
movupd (%rsi,%rcx,8),%xmm2
mulpd  %xmm2,%xmm2
subpd  %xmm2,%xmm3
movupd %xmm3,0x0(%r13,%rcx,8)
movupd (%r15,%rcx,8),%xmm2
movapd %xmm2,%xmm3
addpd  %xmm2,%xmm3
movupd (%rdi,%rcx,8),%xmm4
movapd %xmm4,%xmm5
mulpd  %xmm1,%xmm5
mulpd  %xmm4,%xmm5
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
movupd (%rsi,%rcx,8),%xmm2
movapd %xmm2,%xmm4
mulpd  %xmm1,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm4,(%r11,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1a20 <getP3+0x8d0>
cmp    %r12,%rax
jne    132b <getP3+0x1db>
jmp    13be <getP3+0x26e>
mov    0xd0(%rsp),%edx
jmp    1326 <getP3+0x1d6>
mov    0xd0(%rsp),%edx
jmp    1321 <getP3+0x1d1>
mov    0x28(%rsp),%r13
mov    0x30(%rsp),%r11
mov    0xd0(%rsp),%edx
jmp    1321 <getP3+0x1d1>
mov    0x28(%rsp),%r13
mov    0x30(%rsp),%r11
mov    0xd0(%rsp),%edx
mov    0x38(%rsp),%r15
jmp    1321 <getP3+0x1d1>

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

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