#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 *getP1(double *x, double *y, double *z, double *r2, double *alphas,
              double *betas, int Asize, int Nsize, double *ReX) {
  double *P1 = (double *)malloc(Nsize * Nsize * sizeof(double));
  if (Asize == 0) {
    for (int n = 0; n < Nsize * Nsize; n++) {
      P1[n] = 0.0;
    }
    return P1;
  }
  double sumsInner = 0;
  double sumsOuter = 0;
  double oneO1Palpha;
  double oneO1PalphaSqrt;
  double *alphaO1Palpha = (double *)malloc(Nsize * sizeof(double));
  double *oneO1PalphaSqrt5 = (double *)malloc(Nsize * sizeof(double));
  double *ReXStripe = (double *)malloc(Asize * 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[Nsize + n]);
    oneO1PalphaSqrt = sqrt(oneO1Palpha);
    oneO1PalphaSqrt5[n] = oneO1PalphaSqrt * oneO1Palpha * oneO1Palpha;
    alphaO1Palpha[n] = alphas[Nsize + n] * oneO1Palpha;
  }
  for (int i = 0; i < Asize; i++) {
    for (int j = 0; j < Asize; j++) {
      ReXStripe[i * Asize + j] = ReX[i * Asize + j] + z[i] * z[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[Nsize * Nsize + n * Nsize + k] *
                       betas[Nsize * Nsize + nd * Nsize + kd] *
                       oneO1PalphaSqrt5[k] * oneO1PalphaSqrt5[kd] * sumsInner;
        }
      }
      P1[Nsize * n + nd] = 3.0 * 9.86960440108936 * 0.25 * sumsOuter;
    }
  }
  for (int n = 0; n < Nsize; n++) {
    for (int nd = n + 1; nd < Nsize; nd++) {
      P1[Nsize * nd + n] = P1[Nsize * n + nd];
    }
  }
  free(oneO1PalphaSqrt5);
  free(alphaO1Palpha);
  free(ReXStripe);
  free(kkdij);
  return P1;
}


x86 assembly (clang, -O0):
<getP1>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%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 <getP1+0x93>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    11c6 <getP1+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 <getP1+0x56>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    185b <getP1+0x71b>
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)
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,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    12f7 <getP1+0x1b7>
mov    -0x30(%rbp),%rax
mov    0x18(%rbp),%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd93(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  0xd86(%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
mov    -0x78(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    0x18(%rbp),%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    124e <getP1+0x10e>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    13b6 <getP1+0x276>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    139d <getP1+0x25d>
mov    0x20(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    131a <getP1+0x1da>
jmp    13a2 <getP1+0x262>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1301 <getP1+0x1c1>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    156a <getP1+0x42a>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1551 <getP1+0x411>
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1538 <getP1+0x3f8>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    151f <getP1+0x3df>
mov    -0x80(%rbp),%rax
mov    -0xa0(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0xa4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x70(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0xa4(%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  -0xd0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
mov    -0x98(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x9c(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0xa0(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xa4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    140b <getP1+0x2cb>
jmp    1524 <getP1+0x3e4>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    13f2 <getP1+0x2b2>
jmp    153d <getP1+0x3fd>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    13d9 <getP1+0x299>
jmp    1556 <getP1+0x416>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    13c0 <getP1+0x280>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1790 <getP1+0x650>
mov    -0xa8(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1777 <getP1+0x637>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    173a <getP1+0x5fa>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1721 <getP1+0x5e1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    168c <getP1+0x54c>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1673 <getP1+0x533>
mov    -0x88(%rbp),%rax
mov    -0xb0(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   0x10(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
mov    -0xb8(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0xbc(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1603 <getP1+0x4c3>
jmp    1678 <getP1+0x538>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    15ea <getP1+0x4aa>
mov    -0x38(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0xb0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
mov    -0xac(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
add    -0xb4(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xb4(%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    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    15c9 <getP1+0x489>
jmp    1726 <getP1+0x5e6>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    15b0 <getP1+0x470>
movsd  0x8be(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    -0xac(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    158f <getP1+0x44f>
jmp    177c <getP1+0x63c>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1574 <getP1+0x434>
movl   $0x0,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    182c <getP1+0x6ec>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1813 <getP1+0x6d3>
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xc0(%rbp),%ecx
add    -0xc4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0xc4(%rbp),%ecx
add    -0xc0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    17b8 <getP1+0x678>
jmp    1818 <getP1+0x6d8>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    179a <getP1+0x65a>
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    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getP1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,0x78(%rsp)
mov    %r8,%r14
mov    %rcx,%rbx
mov    %rdx,0x8(%rsp)
mov    0xd8(%rsp),%r13d
mov    0xd0(%rsp),%r15d
mov    %r13d,%ebp
imul   %ebp,%ebp
lea    0x0(,%rbp,8),%edi
call   1050 <malloc@plt>
mov    %rax,0x38(%rsp)
test   %r15d,%r15d
je     1850 <getP1+0x700>
mov    %r14,(%rsp)
mov    %rbx,0x60(%rsp)
lea    0x0(,%r13,8),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %r15d,%eax
imul   %eax,%eax
mov    %rax,0x68(%rsp)
lea    0x0(,%rax,8),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %rbp,0x80(%rsp)
imul   %ebp,%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %r13d,%eax
mov    %rax,0x48(%rsp)
test   %r13d,%r13d
mov    0x8(%rsp),%rdi
jle    129c <getP1+0x14c>
mov    0x48(%rsp),%rax
mov    (%rsp),%rcx
lea    (%rcx,%rax,8),%rbx
xor    %ebp,%ebp
movsd  0xdd8(%rip),%xmm1
xorpd  %xmm2,%xmm2
jmp    127c <getP1+0x12c>
xchg   %ax,%ax
movapd %xmm3,%xmm0
movsd  %xmm3,(%rsp)
call   1070 <sqrt@plt>
movsd  (%rsp),%xmm3
xorpd  %xmm2,%xmm2
movsd  0xdb1(%rip),%xmm1
mov    0x8(%rsp),%rdi
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mov    0x50(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
mulsd  (%rbx,%rbp,8),%xmm3
movsd  %xmm3,(%r14,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,0x48(%rsp)
je     129c <getP1+0x14c>
movsd  (%rbx,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
divsd  %xmm0,%xmm3
ucomisd %xmm2,%xmm3
jb     1230 <getP1+0xe0>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1254 <getP1+0x104>
mov    %r14,0x70(%rsp)
mov    %r15d,%r13d
test   %r15d,%r15d
jle    14d6 <getP1+0x386>
mov    0xe0(%rsp),%rcx
lea    (%rdi,%r13,8),%rax
mov    %rax,0x58(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x88(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x18(%rsp)
mov    0x28(%rsp),%rax
lea    0x10(%rax),%r10
lea    0x0(,%r13,8),%r11
lea    0x10(%rcx),%rdx
mov    %r11,%r14
and    $0xffffffffffffffe0,%r14
lea    0x8(%rcx),%rsi
lea    0x8(%rax),%r8
xor    %r9d,%r9d
mov    %r11,0x20(%rsp)
jmp    1329 <getP1+0x1d9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r9
add    %r11,%r10
add    %r11,%rdx
add    %r11,%rsi
add    %r11,%r8
cmp    %r13,%r9
je     14d6 <getP1+0x386>
mov    %r9,%rax
imul   %r13,%rax
cmp    $0x4,%r15d
jae    13c0 <getP1+0x270>
xor    %ecx,%ecx
mov    %rcx,%rbx
test   $0x1,%r13b
je     1373 <getP1+0x223>
add    %rcx,%rax
movsd  (%rdi,%r9,8),%xmm0
mulsd  (%rdi,%rcx,8),%xmm0
mov    0xe0(%rsp),%rbp
addsd  0x0(%rbp,%rax,8),%xmm0
mov    0x28(%rsp),%rbp
movsd  %xmm0,0x0(%rbp,%rax,8)
mov    %rcx,%rbx
or     $0x1,%rbx
not    %rcx
cmp    0x18(%rsp),%rcx
je     1310 <getP1+0x1c0>
nopl   (%rax)
movsd  (%rdi,%r9,8),%xmm0
mulsd  (%rdi,%rbx,8),%xmm0
addsd  -0x8(%rsi,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%r8,%rbx,8)
movsd  (%rdi,%r9,8),%xmm0
mulsd  0x8(%rdi,%rbx,8),%xmm0
addsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,(%r8,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r13
jne    1380 <getP1+0x230>
jmp    1310 <getP1+0x1c0>
nopl   (%rax)
lea    (%rax,%r13,1),%r11
mov    0x28(%rsp),%rbp
lea    0x0(,%rax,8),%rbx
add    %rbp,%rbx
lea    0x0(%rbp,%r11,8),%rbp
lea    0x8(%rdi,%r9,8),%rcx
mov    %rcx,0x40(%rsp)
lea    (%rdi,%r9,8),%rcx
mov    %rcx,(%rsp)
mov    0xe0(%rsp),%rcx
lea    (%rcx,%r11,8),%r11
mov    0xe0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %r11,%rbx
setb   0x30(%rsp)
cmp    %rbp,%rcx
setb   %r11b
cmp    0x58(%rsp),%rbx
setb   %cl
cmp    %rdi,%rbp
seta   0x10(%rsp)
cmp    0x40(%rsp),%rbx
setb   %bl
cmp    %rbp,(%rsp)
setb   %dil
test   %r11b,0x30(%rsp)
jne    14c5 <getP1+0x375>
and    0x10(%rsp),%cl
jne    14c5 <getP1+0x375>
mov    $0x0,%ecx
and    %dil,%bl
mov    0x8(%rsp),%rdi
mov    0x20(%rsp),%r11
jne    133c <getP1+0x1ec>
movsd  (%rdi,%r9,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rcx,1),%xmm1
movupd (%rdx,%rcx,1),%xmm2
movupd (%rdi,%rcx,1),%xmm3
movupd 0x10(%rdi,%rcx,1),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,-0x10(%r10,%rcx,1)
movupd %xmm4,(%r10,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r14
jne    1470 <getP1+0x320>
mov    0x88(%rsp),%rbp
mov    %rbp,%rcx
cmp    %r13,%rbp
je     1310 <getP1+0x1c0>
jmp    133c <getP1+0x1ec>
xor    %ecx,%ecx
mov    0x8(%rsp),%rdi
mov    0x20(%rsp),%r11
jmp    133c <getP1+0x1ec>
mov    0xd8(%rsp),%eax
test   %eax,%eax
jle    18e8 <getP1+0x798>
movslq %r15d,%rcx
shl    $0x3,%rcx
mov    %rcx,0x30(%rsp)
imul   0x68(%rsp),%eax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
movapd 0xb0b(%rip),%xmm2
xor    %ecx,%ecx
mov    %r13,0x90(%rsp)
jmp    1537 <getP1+0x3e7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
mov    0x18(%rsp),%rax
add    0x40(%rsp),%rax
cmp    %rbx,%rcx
je     1645 <getP1+0x4f5>
mov    %rax,0x18(%rsp)
mov    %rax,0x10(%rsp)
xor    %edx,%edx
jmp    1575 <getP1+0x425>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
mov    0x10(%rsp),%rax
add    0x68(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0x48(%rsp),%rbx
cmp    %rbx,%rdx
mov    0xd0(%rsp),%r15d
je     1520 <getP1+0x3d0>
test   %r15d,%r15d
jle    1550 <getP1+0x400>
mov    0x10(%rsp),%rsi
mov    0x28(%rsp),%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xor    %r14d,%r14d
mov    %rax,(%rsp)
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%r14,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x70(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rsp),%rbp
movsd  0x0(%rbp,%r14,8),%xmm1
mulsd  (%rax,%rdx,8),%xmm1
xorpd  %xmm2,%xmm0
mulsd  0x0(%rbp,%rdi,8),%xmm0
subsd  %xmm1,%xmm0
mov    %rcx,%r15
mov    %r12,%rbx
mov    %rdx,%r12
mov    %rsi,%rbp
mov    %rdi,%r13
call   1060 <exp@plt>
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
mov    %rbx,%r12
mov    %r15,%rcx
movapd 0xa10(%rip),%xmm2
mulsd  0x8(%rsp),%xmm0
lea    0x0(%rbp,%r14,1),%eax
cltq
movsd  %xmm0,(%rbx,%rax,8)
mov    (%rsp),%rax
mov    0x90(%rsp),%r13
add    $0x1,%r14
cmp    %r14,%r13
jne    15a0 <getP1+0x450>
add    $0x1,%rdi
add    0x30(%rsp),%rax
add    %r13,%rsi
cmp    %r13,%rdi
jne    1590 <getP1+0x440>
jmp    1550 <getP1+0x400>
mov    0xd8(%rsp),%eax
test   %eax,%eax
jle    18e8 <getP1+0x798>
mov    0x80(%rsp),%eax
mov    %rax,0x18(%rsp)
lea    -0x1(%r13),%rcx
mov    %r13d,%edx
and    $0x3,%edx
mov    %r13d,%esi
and    $0xfffffffc,%esi
lea    0x18(%r12),%rdi
xor    %r9d,%r9d
movsd  0x988(%rip),%xmm0
jmp    16a2 <getP1+0x552>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x20(%rsp),%r9
add    $0x1,%r9
cmp    %rbx,%r9
je     186f <getP1+0x71f>
mov    %r9,%r8
imul   %rbx,%r8
mov    0x18(%rsp),%rax
mov    %r8,%rbp
mov    %r8,0x58(%rsp)
add    %r8,%rax
mov    %rax,0x30(%rsp)
mov    %r9,0x20(%rsp)
jmp    16f5 <getP1+0x5a5>
cs nopw 0x0(%rax,%rax,1)
nop
mulsd  %xmm0,%xmm1
mov    0x58(%rsp),%rax
mov    0x10(%rsp),%r9
add    %r9,%rax
mov    0x38(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%r9
cmp    %rbx,%r9
je     1690 <getP1+0x540>
mov    %r9,0x10(%rsp)
imul   %rbx,%r9
add    0x18(%rsp),%r9
mov    %r9,0x8(%rsp)
xorpd  %xmm1,%xmm1
xor    %r8d,%r8d
xor    %r9d,%r9d
jmp    1737 <getP1+0x5e7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x60(%rsp),%r9
add    $0x1,%r9
mov    (%rsp),%r8
add    0x40(%rsp),%r8d
cmp    %rbx,%r9
je     16d0 <getP1+0x580>
mov    0x30(%rsp),%rax
add    %r9,%rax
mov    0x78(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm2
mov    0x50(%rsp),%rax
mov    %r9,0x60(%rsp)
movsd  (%rax,%r9,8),%xmm3
mov    %r8,(%rsp)
mov    %r8d,%r10d
xor    %r11d,%r11d
jmp    17b5 <getP1+0x665>
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
add    %r11,%rax
mov    0x78(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm5
mov    0x50(%rsp),%rax
mulsd  (%rax,%r11,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm5,%xmm1
add    $0x1,%r11
add    0x68(%rsp),%r10d
mov    0x48(%rsp),%rbx
cmp    %rbx,%r11
je     1720 <getP1+0x5d0>
xorpd  %xmm4,%xmm4
test   %r15d,%r15d
jle    1770 <getP1+0x620>
mov    %r10d,%eax
xor    %r14d,%r14d
jmp    17dc <getP1+0x68c>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14
add    %r15d,%eax
cmp    %r13,%r14
je     1770 <getP1+0x620>
movslq %eax,%rbx
cmp    $0x3,%rcx
jae    17f0 <getP1+0x6a0>
xor    %r8d,%r8d
jmp    1824 <getP1+0x6d4>
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    1800 <getP1+0x6b0>
test   %rdx,%rdx
je     17d0 <getP1+0x680>
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    1840 <getP1+0x6f0>
jmp    17d0 <getP1+0x680>
test   %ebp,%ebp
je     190e <getP1+0x7be>
mov    %ebp,%edx
shl    $0x3,%rdx
mov    0x38(%rsp),%rdi
xor    %esi,%esi
call   1040 <memset@plt>
jmp    190e <getP1+0x7be>
mov    0xd8(%rsp),%eax
test   %eax,%eax
jle    18e8 <getP1+0x798>
mov    0x38(%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    18bf <getP1+0x76f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %r8,%rdx
add    %r8,%rbp
add    $0xffffffffffffffff,%rdi
cmp    %rbx,%r9
je     18e8 <getP1+0x798>
add    $0x1,%r9
cmp    %rbx,%r9
jae    18b0 <getP1+0x760>
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    18d0 <getP1+0x780>
jmp    18b0 <getP1+0x760>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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