#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 *getP4(double *x, double *y, double *z, double *r2, double *alphas,
              double *betas, int Asize, int Nsize, double *ReX) {
  double *P4 = (double *)malloc(Nsize * Nsize * sizeof(double));
  if (Asize == 0) {
    for (int n = 0; n < Nsize * Nsize; n++) {
      P4[n] = 0.0;
    }
    return P4;
  }
  double sumsInner = 0;
  double sumsOuter = 0;
  double oneO1Palpha;
  double oneO1PalphaSqrt;
  double z2 = 0;
  double *alphaO1Palpha = (double *)malloc(Nsize * sizeof(double));
  double *oneO1PalphaSqrt11 = (double *)malloc(Nsize * sizeof(double));
  double *ReXStripe = (double *)malloc(Asize * Asize * sizeof(double));
  double *zr7 = (double *)malloc(Asize * sizeof(double));
  double *zr73 = (double *)malloc(Asize * sizeof(double));
  double *zr35 = (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[4 * Nsize + n]);
    oneO1PalphaSqrt = sqrt(oneO1Palpha);
    oneO1PalphaSqrt11[n] = oneO1PalphaSqrt * oneO1Palpha * oneO1Palpha *
                           oneO1Palpha * oneO1Palpha * oneO1Palpha;
    alphaO1Palpha[n] = alphas[4 * Nsize + n] * oneO1Palpha;
  }
  for (int i = 0; i < Asize; i++) {
    z2 = z[i] * z[i];
    zr7[i] = 7.0 * z2 - r2[i];
    zr73[i] = 7.0 * z2 - 3.0 * r2[i];
    zr35[i] = 35 * z2 * z2 - 30 * z2 * r2[i] + 3 * r2[i] * r2[i];
  }
  for (int i = 0; i < Asize; i++) {
    for (int j = 0; j < Asize; j++) {
      ReXStripe[i * Asize + j] =
          35.0 * ReX[3 * Asize * Asize + i * Asize + j] +
          z[i] * z[j] *
              (280 * ReX[2 * Asize * Asize + i * Asize + j] +
               40 * zr73[i] * zr73[j] * ReX[i * Asize + j]) +
          20 * zr7[i] * zr7[j] * ReX[Asize * Asize + i * Asize + j] +
          zr35[i] * zr35[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[4 * Nsize * Nsize + n * Nsize + k] *
                       betas[4 * Nsize * Nsize + nd * Nsize + kd] *
                       oneO1PalphaSqrt11[k] * oneO1PalphaSqrt11[kd] * sumsInner;
        }
      }
      P4[Nsize * n + nd] = 9.0 * 9.86960440108936 * 0.00390625 * sumsOuter;
    }
  }
  for (int n = 0; n < Nsize; n++) {
    for (int nd = n + 1; nd < Nsize; nd++) {
      P4[Nsize * nd + n] = P4[Nsize * n + nd];
    }
  }
  free(oneO1PalphaSqrt11);
  free(alphaO1Palpha);
  free(ReXStripe);
  free(zr7);
  free(zr73);
  free(zr35);
  free(kkdij);
  return P4;
}


x86 assembly (clang, -O0):
<getP4>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%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 <getP4+0x93>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    11c6 <getP4+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 <getP4+0x56>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1b9a <getP4+0xa5a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movslq 0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
movslq 0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    0x10(%rbp),%eax
imul   0x10(%rbp),%eax
cltq
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)
movslq 0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq 0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xa0(%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,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1359 <getP4+0x219>
mov    -0x30(%rbp),%rax
mov    0x18(%rbp),%ecx
shl    $0x2,%ecx
add    -0xac(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd7b(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  0xd6e(%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
mov    -0x80(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    0x18(%rbp),%ecx
shl    $0x2,%ecx
add    -0xac(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    129b <getP4+0x15b>
movl   $0x0,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    14e2 <getP4+0x3a2>
mov    -0x20(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xc6d(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  0xc2a(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xc16(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xbcb(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  0xbd9(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  0xb8a(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1363 <getP4+0x223>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    16c5 <getP4+0x585>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    16ac <getP4+0x56c>
mov    0x20(%rbp),%rax
imul   $0x3,0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xb8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0xb8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   0x10(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xb8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x98(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  0xa88(%rip),%xmm3
mulsd  (%rax,%rcx,8),%xmm3
mov    -0x98(%rbp),%rax
movslq -0xb8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
mov    0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xb8(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm3
movsd  0xa44(%rip),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0xa28(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  0xa02(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x90(%rbp),%rax
movslq -0xb8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xb8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xa0(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
mov    -0xb4(%rbp),%ecx
imul   0x10(%rbp),%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    1505 <getP4+0x3c5>
jmp    16b1 <getP4+0x571>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    14ec <getP4+0x3ac>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    187c <getP4+0x73c>
movl   $0x0,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1863 <getP4+0x723>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    184a <getP4+0x70a>
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1831 <getP4+0x6f1>
mov    -0x88(%rbp),%rax
mov    -0xc4(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xc8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
mov    -0xbc(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xc0(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0xc4(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xc8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    171a <getP4+0x5da>
jmp    1836 <getP4+0x6f6>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1701 <getP4+0x5c1>
jmp    184f <getP4+0x70f>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    16e8 <getP4+0x5a8>
jmp    1868 <getP4+0x728>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    16cf <getP4+0x58f>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1aa8 <getP4+0x968>
mov    -0xcc(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1a8f <getP4+0x94f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1a52 <getP4+0x912>
movl   $0x0,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1a39 <getP4+0x8f9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    199e <getP4+0x85e>
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1985 <getP4+0x845>
mov    -0xa8(%rbp),%rax
mov    -0xd4(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xd8(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0xdc(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xe0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    1915 <getP4+0x7d5>
jmp    198a <getP4+0x84a>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    18fc <getP4+0x7bc>
mov    -0x38(%rbp),%rax
mov    0x18(%rbp),%ecx
shl    $0x2,%ecx
imul   0x18(%rbp),%ecx
mov    -0xcc(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    0x18(%rbp),%ecx
shl    $0x2,%ecx
imul   0x18(%rbp),%ecx
mov    -0xd0(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0xd8(%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    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    18db <getP4+0x79b>
jmp    1a3e <getP4+0x8fe>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    18c2 <getP4+0x782>
movsd  0x5a6(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    18a1 <getP4+0x761>
jmp    1a94 <getP4+0x954>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1886 <getP4+0x746>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1b44 <getP4+0xa04>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1b2b <getP4+0x9eb>
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xe8(%rbp),%ecx
add    -0xe4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    1ad0 <getP4+0x990>
jmp    1b30 <getP4+0x9f0>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1ab2 <getP4+0x972>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getP4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,0x90(%rsp)
mov    %r8,%r12
mov    %rcx,%r15
mov    %rdx,%rbp
mov    0xe8(%rsp),%r13d
mov    0xe0(%rsp),%r14d
mov    %r13d,%ebx
imul   %ebx,%ebx
lea    0x0(,%rbx,8),%edi
call   1050 <malloc@plt>
mov    %rax,0x20(%rsp)
test   %r14d,%r14d
je     1870 <getP4+0x720>
mov    %r12,0x8(%rsp)
mov    %rbp,0x10(%rsp)
mov    %r15,0x30(%rsp)
lea    0x0(,%r13,8),%r15d
mov    %r15d,%edi
call   1050 <malloc@plt>
mov    %r15d,%edi
mov    %rax,%r15
call   1050 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %r14d,%eax
imul   %eax,%eax
mov    %rax,0x38(%rsp)
lea    0x0(,%rax,8),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x50(%rsp)
lea    0x0(,%r14,8),%r12d
mov    %r12d,%edi
call   1050 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %r12d,%edi
call   1050 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    %r12d,%edi
call   1050 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %rbx,0x68(%rsp)
imul   %ebx,%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %r13,%rax
mov    %eax,%r13d
test   %eax,%eax
jle    12e3 <getP4+0x193>
mov    0xe8(%rsp),%eax
lea    0x0(,%rax,4),%eax
cltq
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,8),%rbx
xor    %ebp,%ebp
movsd  0xd9f(%rip),%xmm1
xorpd  %xmm2,%xmm2
jmp    12c3 <getP4+0x173>
nopw   0x0(%rax,%rax,1)
movapd %xmm3,%xmm0
movsd  %xmm3,0x8(%rsp)
call   1070 <sqrt@plt>
movsd  0x8(%rsp),%xmm3
xorpd  %xmm2,%xmm2
movsd  0xd6f(%rip),%xmm1
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mov    0x40(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
mulsd  (%rbx,%rbp,8),%xmm3
movsd  %xmm3,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
je     12e3 <getP4+0x193>
movsd  (%rbx,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
divsd  %xmm0,%xmm3
ucomisd %xmm2,%xmm3
jb     1270 <getP4+0x120>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1291 <getP4+0x141>
mov    %r13,0x88(%rsp)
mov    %r15,0x80(%rsp)
mov    %r14d,%r15d
test   %r14d,%r14d
jle    1501 <getP4+0x3b1>
xor    %eax,%eax
movsd  0xcff(%rip),%xmm1
movsd  0xcff(%rip),%xmm2
movsd  0xcff(%rip),%xmm0
movsd  0xcff(%rip),%xmm3
movsd  0xcff(%rip),%xmm4
mov    0x60(%rsp),%rcx
mov    0x58(%rsp),%rdx
mov    0x48(%rsp),%rsi
mov    0x30(%rsp),%rdi
mov    0x10(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm5
mulsd  %xmm5,%xmm5
movapd %xmm5,%xmm6
mulsd  %xmm1,%xmm6
movapd %xmm6,%xmm7
subsd  (%rdi,%rax,8),%xmm7
movsd  %xmm7,(%rcx,%rax,8)
movsd  (%rdi,%rax,8),%xmm7
mulsd  %xmm2,%xmm7
addsd  %xmm6,%xmm7
movsd  %xmm7,(%rdx,%rax,8)
movapd %xmm5,%xmm6
mulsd  %xmm0,%xmm6
movsd  (%rdi,%rax,8),%xmm7
mulsd  %xmm5,%xmm6
mulsd  %xmm3,%xmm5
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
movapd %xmm7,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm7,%xmm6
addsd  %xmm5,%xmm6
movsd  %xmm6,(%rsi,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1350 <getP4+0x200>
test   %r14d,%r14d
mov    0xf0(%rsp),%rbp
jle    1501 <getP4+0x3b1>
mov    0x38(%rsp),%rsi
lea    (%rsi,%rsi,2),%r13d
lea    (%rsi,%rsi,1),%eax
lea    0x0(,%r15,8),%rdi
mov    %rdi,0x8(%rsp)
mov    %esi,%ecx
xor    %r8d,%r8d
movsd  0xc3c(%rip),%xmm1
movsd  0xc3c(%rip),%xmm2
movsd  0xc3c(%rip),%xmm3
mov    %rbp,%rdi
mov    0x50(%rsp),%rsi
mov    0x48(%rsp),%r9
mov    0x10(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rbx,%r13,1),%ebp
movsd  (%r10,%r8,8),%xmm4
mulsd  (%r10,%rbx,8),%xmm4
movslq %ebp,%rbp
lea    (%rax,%rbx,1),%r11d
mov    0x58(%rsp),%rdx
movsd  (%rdx,%r8,8),%xmm5
mulsd  %xmm1,%xmm5
mulsd  (%rdx,%rbx,8),%xmm5
mulsd  (%rdi,%rbx,8),%xmm5
movslq %r11d,%rdx
mov    0xf0(%rsp),%r11
movsd  (%r11,%rdx,8),%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm4,%xmm6
mov    0xf0(%rsp),%rdx
movsd  (%rdx,%rbp,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm6,%xmm4
mov    0x60(%rsp),%rdx
movsd  (%rdx,%r8,8),%xmm5
mulsd  %xmm3,%xmm5
mulsd  (%rdx,%rbx,8),%xmm5
lea    (%rcx,%rbx,1),%edx
movslq %edx,%rdx
mov    0xf0(%rsp),%rbp
mulsd  0x0(%rbp,%rdx,8),%xmm5
addsd  %xmm4,%xmm5
movsd  (%r9,%r8,8),%xmm4
mulsd  (%r9,%rbx,8),%xmm4
addsd  %xmm5,%xmm4
movsd  %xmm4,(%rsi,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1430 <getP4+0x2e0>
add    $0x1,%r8
mov    0x8(%rsp),%rbp
add    %rbp,%rsi
add    %rbp,%rdi
add    %r15,%rcx
add    %r15,%rax
add    %r15,%r13
cmp    %r15,%r8
jne    1420 <getP4+0x2d0>
mov    0xe8(%rsp),%eax
test   %eax,%eax
jle    1908 <getP4+0x7b8>
movslq %r14d,%rcx
shl    $0x3,%rcx
mov    %rcx,0x70(%rsp)
imul   0x38(%rsp),%eax
mov    %rax,0x78(%rsp)
xor    %eax,%eax
movapd 0xb20(%rip),%xmm2
xor    %ecx,%ecx
mov    %r15,0xa0(%rsp)
jmp    1557 <getP4+0x407>
nopl   0x0(%rax)
add    $0x1,%rcx
mov    0x28(%rsp),%rax
add    0x78(%rsp),%rax
cmp    %rbx,%rcx
je     1665 <getP4+0x515>
mov    %rax,0x28(%rsp)
mov    %rax,0x18(%rsp)
xor    %edx,%edx
jmp    1598 <getP4+0x448>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
mov    0x18(%rsp),%rax
add    0x38(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    0x88(%rsp),%rbx
cmp    %rbx,%rdx
mov    0xe0(%rsp),%r14d
je     1540 <getP4+0x3f0>
test   %r14d,%r14d
jle    1570 <getP4+0x420>
mov    0x18(%rsp),%rsi
mov    0x50(%rsp),%rax
xor    %edi,%edi
nopl   0x0(%rax)
xor    %ebp,%ebp
mov    %rax,0x10(%rsp)
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x80(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rsp),%rbx
movsd  (%rbx,%rbp,8),%xmm1
mulsd  (%rax,%rdx,8),%xmm1
xorpd  %xmm2,%xmm0
mulsd  (%rbx,%rdi,8),%xmm0
subsd  %xmm1,%xmm0
mov    %rcx,%r14
mov    %r12,%r13
mov    %rdx,%r12
mov    %rsi,%rbx
mov    %rdi,%r15
call   1060 <exp@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
mov    %r13,%r12
mov    %r14,%rcx
movapd 0xa31(%rip),%xmm2
mulsd  0x8(%rsp),%xmm0
lea    (%rbx,%rbp,1),%eax
cltq
movsd  %xmm0,0x0(%r13,%rax,8)
mov    0x10(%rsp),%rax
mov    0xa0(%rsp),%r15
add    $0x1,%rbp
cmp    %rbp,%r15
jne    15c0 <getP4+0x470>
add    $0x1,%rdi
add    0x70(%rsp),%rax
add    %r15,%rsi
cmp    %r15,%rdi
jne    15b0 <getP4+0x460>
jmp    1570 <getP4+0x420>
mov    0xe8(%rsp),%eax
test   %eax,%eax
jle    1908 <getP4+0x7b8>
mov    0x68(%rsp),%rax
shl    $0x2,%eax
cltq
mov    %rax,0x28(%rsp)
lea    -0x1(%r15),%rcx
mov    %r15d,%edx
and    $0x3,%edx
mov    %r15d,%esi
and    $0xfffffffc,%esi
lea    0x18(%r12),%rdi
xor    %r9d,%r9d
movsd  0x9a5(%rip),%xmm0
jmp    16c5 <getP4+0x575>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x98(%rsp),%r9
add    $0x1,%r9
cmp    %rbx,%r9
je     188f <getP4+0x73f>
mov    %r9,%r8
imul   %rbx,%r8
mov    0x28(%rsp),%rax
mov    %r8,%rbp
mov    %r8,0x68(%rsp)
add    %r8,%rax
mov    %rax,0x70(%rsp)
mov    %r9,0x98(%rsp)
jmp    1715 <getP4+0x5c5>
nopl   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
mov    0x68(%rsp),%rax
mov    0x18(%rsp),%r9
add    %r9,%rax
mov    0x20(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%r9
cmp    %rbx,%r9
je     16b0 <getP4+0x560>
mov    %r9,0x18(%rsp)
imul   %rbx,%r9
add    0x28(%rsp),%r9
mov    %r9,0x8(%rsp)
xorpd  %xmm1,%xmm1
xor    %r8d,%r8d
xor    %r9d,%r9d
jmp    1758 <getP4+0x608>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x30(%rsp),%r9
add    $0x1,%r9
mov    0x10(%rsp),%r8
add    0x78(%rsp),%r8d
cmp    %rbx,%r9
je     16f0 <getP4+0x5a0>
mov    0x70(%rsp),%rax
add    %r9,%rax
mov    0x90(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm2
mov    0x40(%rsp),%rax
mov    %r9,0x30(%rsp)
movsd  (%rax,%r9,8),%xmm3
mov    %r8,0x10(%rsp)
mov    %r8d,%r10d
xor    %r11d,%r11d
jmp    17db <getP4+0x68b>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
add    %r11,%rax
mov    0x90(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm5
mov    0x40(%rsp),%rax
mulsd  (%rax,%r11,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm5,%xmm1
add    $0x1,%r11
add    0x38(%rsp),%r10d
mov    0x88(%rsp),%rbx
cmp    %rbx,%r11
je     1740 <getP4+0x5f0>
xorpd  %xmm4,%xmm4
test   %r14d,%r14d
jle    1790 <getP4+0x640>
mov    %r10d,%eax
xor    %r13d,%r13d
jmp    17fc <getP4+0x6ac>
nopl   0x0(%rax)
add    $0x1,%r13
add    %r14d,%eax
cmp    %r15,%r13
je     1790 <getP4+0x640>
movslq %eax,%rbx
cmp    $0x3,%rcx
jae    1810 <getP4+0x6c0>
xor    %r8d,%r8d
jmp    1844 <getP4+0x6f4>
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%rbx,8),%r9
xor    %r8d,%r8d
nopw   0x0(%rax,%rax,1)
addsd  -0x18(%r9,%r8,8),%xmm4
addsd  -0x10(%r9,%r8,8),%xmm4
addsd  -0x8(%r9,%r8,8),%xmm4
addsd  (%r9,%r8,8),%xmm4
add    $0x4,%r8
cmp    %r8,%rsi
jne    1820 <getP4+0x6d0>
test   %rdx,%rdx
je     17f0 <getP4+0x6a0>
add    %rbx,%r8
lea    (%r12,%r8,8),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  (%rbx,%rbp,8),%xmm4
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1860 <getP4+0x710>
jmp    17f0 <getP4+0x6a0>
test   %ebx,%ebx
je     194f <getP4+0x7ff>
mov    %ebx,%edx
shl    $0x3,%rdx
mov    0x20(%rsp),%rdi
xor    %esi,%esi
call   1040 <memset@plt>
jmp    194f <getP4+0x7ff>
mov    0xe8(%rsp),%eax
test   %eax,%eax
jle    1908 <getP4+0x7b8>
mov    0x20(%rsp),%rbp
lea    0x0(,%rbx,8),%rdx
add    %rbp,%rdx
lea    0x0(,%rbx,8),%rcx
lea    0x8(,%rbx,8),%r8
xor    %r9d,%r9d
mov    %rbx,%rdi
jmp    18df <getP4+0x78f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %r8,%rdx
add    %r8,%rbp
add    $0xffffffffffffffff,%rdi
cmp    %rbx,%r9
je     1908 <getP4+0x7b8>
add    $0x1,%r9
cmp    %rbx,%r9
jae    18d0 <getP4+0x780>
mov    $0x1,%esi
mov    %rdx,%rax
movsd  0x0(%rbp,%rsi,8),%xmm0
movsd  %xmm0,(%rax)
add    %rcx,%rax
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    18f0 <getP4+0x7a0>
jmp    18d0 <getP4+0x780>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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