#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 */
int /*<<< orphan*/ EvalPts(int, double *);
int /*<<< orphan*/ L2_an(int, int);
int /*<<< orphan*/ L2_cn(int, int);
int /*<<< orphan*/ Pmm_L2(int, double *, int, double *);
int /*<<< orphan*/ memcpy(double *, double *, int);
int /*<<< orphan*/ vec_add(double *, double *, double *, int);
int /*<<< orphan*/ vec_mul(int /*<<< orphan*/, double *, double *, int);
int /*<<< orphan*/ vec_pt_mul(double *, double *, double *, int);
void P_eval(int m, double *coeffs, double *eval_args, double *result,
            double *workspace, int bw) {
  double *prev, *prevprev, *temp1, *temp2, *temp3, *temp4, *x_i;
  int i, j, n;
  double splat;
  prevprev = workspace;
  prev = prevprev + (2 * bw);
  temp1 = prev + (2 * bw);
  temp2 = temp1 + (2 * bw);
  temp3 = temp2 + (2 * bw);
  temp4 = temp3 + (2 * bw);
  x_i = temp4 + (2 * bw);
  n = 2 * bw;
  EvalPts(n, x_i);
  for (i = 0; i < n; i++)
    prevprev[i] = 0.0;
  if (m == 0) {
    for (i = 0; i < n; i++) {
      prev[i] = 0.707106781186547;
      result[i] = coeffs[0] * prev[i];
    }
  } else {
    Pmm_L2(m, eval_args, n, prev);
    splat = coeffs[0];
    for (i = 0; i < n; i++)
      result[i] = splat * prev[i];
  }
  for (i = 0; i < bw - m - 1; i++) {
    vec_mul(L2_cn(m, m + i), prevprev, temp1, n);
    vec_pt_mul(prev, x_i, temp2, n);
    vec_mul(L2_an(m, m + i), temp2, temp3, n);
    vec_add(temp3, temp1, temp4, n);
    splat = coeffs[i + 1];
    for (j = 0; j < n; j++)
      result[j] += splat * temp4[j];
    memcpy(prevprev, prev, sizeof(double) * n);
    memcpy(prev, temp4, sizeof(double) * n);
  }
}


x86 assembly (clang, -O0):
<P_eval>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%edi
mov    -0x68(%rbp),%rsi
call   1090 <EvalPts@plt>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1280 <P_eval+0x100>
mov    -0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1256 <P_eval+0xd6>
cmpl   $0x0,-0x4(%rbp)
jne    12e7 <P_eval+0x167>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    12e2 <P_eval+0x162>
mov    -0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  0xd53(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1291 <P_eval+0x111>
jmp    134c <P_eval+0x1cc>
mov    -0x4(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x74(%rbp),%edx
mov    -0x38(%rbp),%rcx
call   1030 <Pmm_L2@plt>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1347 <P_eval+0x1c7>
movsd  -0x80(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    130e <P_eval+0x18e>
jmp    134c <P_eval+0x1cc>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    146f <P_eval+0x2ef>
mov    -0x4(%rbp),%edi
mov    -0x4(%rbp),%esi
add    -0x6c(%rbp),%esi
call   1060 <L2_cn@plt>
mov    %eax,%edi
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x74(%rbp),%ecx
call   1080 <vec_mul@plt>
mov    -0x38(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x74(%rbp),%ecx
call   10a0 <vec_pt_mul@plt>
mov    -0x4(%rbp),%edi
mov    -0x4(%rbp),%esi
add    -0x6c(%rbp),%esi
call   1040 <L2_an@plt>
mov    %eax,%edi
mov    -0x50(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x74(%rbp),%ecx
call   1080 <vec_mul@plt>
mov    -0x58(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x74(%rbp),%ecx
call   1050 <vec_add@plt>
mov    -0x10(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1433 <P_eval+0x2b3>
movsd  -0x80(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    13ed <P_eval+0x26d>
mov    -0x40(%rbp),%rdi
mov    -0x38(%rbp),%rsi
movslq -0x74(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1070 <memcpy@plt>
mov    -0x38(%rbp),%rdi
mov    -0x60(%rbp),%rsi
movslq -0x74(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1070 <memcpy@plt>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1353 <P_eval+0x1d3>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<P_eval>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9d,%ebp
mov    %r8,%r12
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %rsi,0x10(%rsp)
mov    %edi,%r15d
lea    0x0(%rbp,%rbp,1),%r13d
movslq %r13d,%rdi
lea    (%r8,%rdi,8),%rax
mov    %rax,0x18(%rsp)
lea    (%rax,%rdi,8),%rax
mov    %rax,0x50(%rsp)
lea    (%rax,%rdi,8),%rax
mov    %rax,0xa8(%rsp)
lea    (%rax,%rdi,8),%rax
mov    %rax,0xa0(%rsp)
lea    (%rax,%rdi,8),%rax
mov    %rax,0x48(%rsp)
lea    (%rax,%rdi,8),%rsi
mov    %rdi,0x20(%rsp)
mov    %rsi,0x98(%rsp)
call   10a0 <EvalPts@plt>
mov    %rbp,0x30(%rsp)
test   %ebp,%ebp
mov    %r13d,0x2c(%rsp)
jle    1289 <P_eval+0xf9>
mov    %r14,0x38(%rsp)
cmp    $0x2,%r13d
mov    $0x1,%r14d
mov    $0x1,%edx
cmovge %r13d,%edx
shl    $0x3,%rdx
mov    %r12,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
test   %r15d,%r15d
mov    %r12,%rbp
mov    %r15,%rdi
je     12bc <P_eval+0x12c>
mov    %rdi,%r15
mov    0x38(%rsp),%rsi
mov    %r13d,%edx
mov    0x18(%rsp),%rcx
call   1030 <Pmm_L2@plt>
mov    0x10(%rsp),%rax
movsd  (%rax),%xmm0
cmp    $0x2,%r13d
cmovge %r13d,%r14d
cmp    $0x4,%r14d
mov    0x20(%rsp),%r12
jae    1362 <P_eval+0x1d2>
xor    %eax,%eax
mov    0x18(%rsp),%r13
mov    %r15,%rdi
jmp    1588 <P_eval+0x3f8>
test   %r15d,%r15d
mov    %r12,%rbp
mov    0x18(%rsp),%r13
mov    0x20(%rsp),%r12
mov    %r15,%rdi
je     1617 <P_eval+0x487>
mov    %r14,%rsi
mov    0x2c(%rsp),%edx
mov    %r13,%rcx
mov    %rdi,%r14
call   1030 <Pmm_L2@plt>
mov    %r14,%rdi
jmp    1617 <P_eval+0x487>
cmp    $0x2,%r13d
cmovge %r13d,%r14d
cmp    $0x4,%r14d
mov    0x20(%rsp),%r12
jae    1396 <P_eval+0x206>
xor    %eax,%eax
mov    0x18(%rsp),%r13
mov    %rax,%rdx
not    %rdx
movabs $0x3fe6a09e667f3bc8,%rcx
a0 e6 3f
test   $0x1,%r14b
je     130f <P_eval+0x17f>
mov    %rcx,0x0(%r13,%rax,8)
mov    0x10(%rsp),%rsi
movsd  (%rsi),%xmm0
mulsd  0xcfa(%rip),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
or     $0x1,%rax
add    %r14,%rdx
je     1617 <P_eval+0x487>
lea    0x8(,%r12,8),%rdx
add    %rbp,%rdx
movsd  0xcd5(%rip),%xmm0
mov    0x10(%rsp),%rsi
mov    %rcx,-0x8(%rdx,%rax,8)
movsd  (%rsi),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
mov    %rcx,(%rdx,%rax,8)
movsd  (%rsi),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1330 <P_eval+0x1a0>
jmp    1617 <P_eval+0x487>
lea    (%r12,%r14,1),%rax
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    %rbx,%rax
mov    0x18(%rsp),%r13
jbe    14cf <P_eval+0x33f>
lea    (%rbx,%r14,8),%rax
cmp    %rax,%r13
jae    14cf <P_eval+0x33f>
xor    %eax,%eax
mov    %r15,%rdi
jmp    1588 <P_eval+0x3f8>
lea    (%r12,%r14,1),%rax
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
lea    (%rbx,%r14,8),%rcx
mov    0x10(%rsp),%rsi
lea    0x8(%rsi),%rdx
mov    0x18(%rsp),%r13
cmp    %rcx,%r13
setb   %r8b
cmp    %rbx,%rax
seta   %r9b
cmp    %rdx,%r13
setb   %r11b
cmp    %rsi,%rax
seta   %r10b
cmp    %rbx,%rdx
seta   %dl
cmp    %rsi,%rcx
seta   %sil
xor    %eax,%eax
test   %r9b,%r8b
jne    12da <P_eval+0x14a>
and    %r10b,%r11b
jne    12da <P_eval+0x14a>
and    %sil,%dl
jne    12da <P_eval+0x14a>
mov    %r14d,%eax
and    $0x7ffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     197f <P_eval+0x7ef>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x10(%rsp),%rdx
movsd  (%rdx),%xmm0
mulsd  0xbcb(%rip),%xmm0
unpcklpd %xmm0,%xmm0
lea    0x30(,%r12,8),%rcx
add    %rbp,%rcx
xor    %edx,%edx
movapd 0xbc2(%rip),%xmm1
xchg   %ax,%ax
movupd %xmm1,-0x30(%rcx,%rdx,8)
movupd %xmm1,-0x20(%rcx,%rdx,8)
movupd %xmm0,(%rbx,%rdx,8)
movupd %xmm0,0x10(%rbx,%rdx,8)
movupd %xmm1,-0x10(%rcx,%rdx,8)
movupd %xmm1,(%rcx,%rdx,8)
movupd %xmm0,0x20(%rbx,%rdx,8)
movupd %xmm0,0x30(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1450 <P_eval+0x2c0>
test   $0x1,%r8b
je     14c1 <P_eval+0x331>
movaps 0xb7b(%rip),%xmm0
movups %xmm0,0x0(%r13,%rdx,8)
movups %xmm0,0x10(%r13,%rdx,8)
mov    0x10(%rsp),%rcx
movsd  (%rcx),%xmm0
mulsd  0xb4e(%rip),%xmm0
unpcklpd %xmm0,%xmm0
movupd %xmm0,(%rbx,%rdx,8)
movupd %xmm0,0x10(%rbx,%rdx,8)
cmp    %r14,%rax
jne    12da <P_eval+0x14a>
jmp    1617 <P_eval+0x487>
mov    %r14d,%eax
and    $0x7ffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rax),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
mov    %r15,%rdi
je     196e <P_eval+0x7de>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
lea    0x30(,%r12,8),%rcx
add    %rbp,%rcx
xor    %edx,%edx
xchg   %ax,%ax
movupd -0x30(%rcx,%rdx,8),%xmm2
movupd -0x20(%rcx,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rbx,%rdx,8)
movupd %xmm3,0x10(%rbx,%rdx,8)
movupd -0x10(%rcx,%rdx,8),%xmm2
movupd (%rcx,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rbx,%rdx,8)
movupd %xmm3,0x30(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1510 <P_eval+0x380>
test   $0x1,%r8b
je     157f <P_eval+0x3ef>
movupd 0x0(%r13,%rdx,8),%xmm2
movupd 0x10(%r13,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rbx,%rdx,8)
movupd %xmm3,0x10(%rbx,%rdx,8)
cmp    %r14,%rax
je     1617 <P_eval+0x487>
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
mov    %r14,%rdx
and    $0x3,%rdx
je     15ba <P_eval+0x42a>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    15a0 <P_eval+0x410>
cmp    $0x3,%rcx
jb     1617 <P_eval+0x487>
lea    0x18(,%r12,8),%rcx
add    %rbp,%rcx
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  -0x10(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
movsd  -0x8(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rbx,%rax,8)
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    15d0 <P_eval+0x440>
mov    %rdi,0xb0(%rsp)
mov    %edi,%eax
not    %eax
add    0x30(%rsp),%eax
test   %eax,%eax
mov    0x48(%rsp),%r8
jle    195c <P_eval+0x7cc>
mov    0x30(%rsp),%rcx
shl    $0x4,%ecx
mov    %ecx,0x44(%rsp)
mov    0x2c(%rsp),%ecx
cmp    $0x2,%ecx
mov    $0x1,%edi
cmovge %ecx,%edi
mov    %eax,%eax
mov    %rax,0x80(%rsp)
lea    (%r12,%r12,4),%rax
lea    (%rax,%rdi,1),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
mov    %edi,%edx
and    $0x7ffffffc,%edx
mov    %rdx,0x70(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x68(%rsp)
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
cmp    %rbx,%rcx
seta   %cl
lea    (%rbx,%rdi,8),%rdx
cmp    %rdx,%r8
setb   %dl
and    %cl,%dl
mov    %dl,0xf(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x60(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x58(%rsp)
mov    %rdi,0x88(%rsp)
neg    %rdi
mov    %rdi,0x78(%rsp)
lea    0x30(,%rax,8),%r12
add    %rbp,%r12
xor    %eax,%eax
mov    %rbp,0x90(%rsp)
jmp    1721 <P_eval+0x591>
nopl   0x0(%rax,%rax,1)
mov    0x90(%rsp),%r14
mov    %r14,%rdi
mov    0x18(%rsp),%r13
mov    %r13,%rsi
mov    0x44(%rsp),%ebp
mov    %ebp,%edx
call   1080 <memcpy@plt>
mov    %r13,%rdi
mov    %r15,%rsi
mov    %ebp,%edx
mov    %r14,%rbp
call   1080 <memcpy@plt>
mov    0x20(%rsp),%rax
cmp    0x80(%rsp),%rax
je     195c <P_eval+0x7cc>
mov    %rax,0x38(%rsp)
mov    %r13,%r15
mov    0xb0(%rsp),%r13
lea    (%rax,%r13,1),%esi
mov    %esi,0x20(%rsp)
mov    %r13d,%edi
call   1070 <L2_cn@plt>
mov    %eax,%edi
mov    %rbp,%rsi
mov    0x50(%rsp),%rdx
mov    0x2c(%rsp),%r14d
mov    %r14d,%ecx
call   1090 <vec_mul@plt>
mov    %r15,%rdi
mov    0x98(%rsp),%rsi
mov    0xa8(%rsp),%r15
mov    %r15,%rdx
mov    %r14d,%ecx
call   10b0 <vec_pt_mul@plt>
mov    %r13d,%edi
mov    0x20(%rsp),%esi
call   1040 <L2_an@plt>
mov    %eax,%edi
mov    %r15,%rsi
mov    0x48(%rsp),%r15
mov    0xa0(%rsp),%rbp
mov    %rbp,%rdx
mov    %r14d,%ecx
call   1090 <vec_mul@plt>
mov    %rbp,%rdi
mov    0x50(%rsp),%rsi
mov    %r15,%rdx
mov    %r14d,%ecx
call   1060 <vec_add@plt>
mov    0x38(%rsp),%rcx
lea    0x1(%rcx),%rax
mov    %rax,0x20(%rsp)
cmpl   $0x0,0x30(%rsp)
mov    0x88(%rsp),%rdx
jle    16e0 <P_eval+0x550>
mov    0x10(%rsp),%rax
movsd  0x8(%rax,%rcx,8),%xmm0
cmp    $0x4,%edx
setb   %al
or     0xf(%rsp),%al
je     1800 <P_eval+0x670>
xor    %ecx,%ecx
jmp    18de <P_eval+0x74e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x68(%rsp)
je     194a <P_eval+0x7ba>
mov    0x58(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r12,%rax,8),%xmm2
movupd -0x20(%r12,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rbx,%rax,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rbx,%rax,8),%xmm2
movupd 0x20(%rbx,%rax,8),%xmm5
movupd 0x30(%rbx,%rax,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rbx,%rax,8)
movupd %xmm3,0x10(%rbx,%rax,8)
movupd -0x10(%r12,%rax,8),%xmm2
movupd (%r12,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rbx,%rax,8)
movupd %xmm3,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1820 <P_eval+0x690>
testb  $0x1,0x60(%rsp)
je     18cd <P_eval+0x73d>
movupd (%r15,%rax,8),%xmm2
movupd 0x10(%r15,%rax,8),%xmm3
movupd (%rbx,%rax,8),%xmm4
movupd 0x10(%rbx,%rax,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm3,0x10(%rbx,%rax,8)
mov    0x70(%rsp),%rax
mov    %rax,%rcx
cmp    %rdx,%rax
je     16e0 <P_eval+0x550>
mov    %rcx,%rax
test   $0x1,%dl
je     1901 <P_eval+0x771>
movsd  (%r15,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x78(%rsp),%rcx
je     16e0 <P_eval+0x550>
nop
movsd  -0x30(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  -0x28(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1910 <P_eval+0x780>
jmp    16e0 <P_eval+0x550>
xor    %eax,%eax
testb  $0x1,0x60(%rsp)
jne    189a <P_eval+0x70a>
jmp    18cd <P_eval+0x73d>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    155e <P_eval+0x3ce>
jmp    157f <P_eval+0x3ef>
xor    %edx,%edx
test   $0x1,%r8b
jne    148e <P_eval+0x2fe>
jmp    14c1 <P_eval+0x331>

LLVM IR (-O0):
define void @P_eval(i32 %0, double* %1, double* %2, double* %3, double* %4, i32 %5) {
%7 = alloca i32
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca i32
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca double*
%18 = alloca double*
%19 = alloca double*
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca double
store i32 %0, i32* %7
store double* %1, double** %8
store double* %2, double** %9
store double* %3, double** %10
store double* %4, double** %11
store i32 %5, i32* %12
%24 = load double*, double** %11
store double* %24, double** %14
%25 = load double*, double** %14
%26 = load i32, i32* %12
%27 = mul nsw i32 2, %26
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds double, double* %25, i64 %28
store double* %29, double** %13
%30 = load double*, double** %13
%31 = load i32, i32* %12
%32 = mul nsw i32 2, %31
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds double, double* %30, i64 %33
store double* %34, double** %15
%35 = load double*, double** %15
%36 = load i32, i32* %12
%37 = mul nsw i32 2, %36
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds double, double* %35, i64 %38
store double* %39, double** %16
%40 = load double*, double** %16
%41 = load i32, i32* %12
%42 = mul nsw i32 2, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %40, i64 %43
store double* %44, double** %17
%45 = load double*, double** %17
%46 = load i32, i32* %12
%47 = mul nsw i32 2, %46
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds double, double* %45, i64 %48
store double* %49, double** %18
%50 = load double*, double** %18
%51 = load i32, i32* %12
%52 = mul nsw i32 2, %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds double, double* %50, i64 %53
store double* %54, double** %19
%55 = load i32, i32* %12
%56 = mul nsw i32 2, %55
store i32 %56, i32* %22
%57 = load i32, i32* %22
%58 = load double*, double** %19
%59 = call i32 @EvalPts(i32 %57, double* %58)
store i32 0, i32* %20
br label %60
60: ; preds = %69, %6
%61 = load i32, i32* %20
%62 = load i32, i32* %22
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %72
64: ; preds = %60
%65 = load double*, double** %14
%66 = load i32, i32* %20
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %65, i64 %67
store double 0.000000e+00, double* %68
br label %69
69: ; preds = %64
%70 = load i32, i32* %20
%71 = add nsw i32 %70, 1
store i32 %71, i32* %20
br label %60
72: ; preds = %60
%73 = load i32, i32* %7
%74 = icmp eq i32 %73, 0
br i1 %74, label %75, label %102
75: ; preds = %72
store i32 0, i32* %20
br label %76
76: ; preds = %98, %75
%77 = load i32, i32* %20
%78 = load i32, i32* %22
%79 = icmp slt i32 %77, %78
br i1 %79, label %80, label %101
80: ; preds = %76
%81 = load double*, double** %13
%82 = load i32, i32* %20
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %81, i64 %83
store double 0x3FE6A09E667F3BC8, double* %84
%85 = load double*, double** %8
%86 = getelementptr inbounds double, double* %85, i64 0
%87 = load double, double* %86
%88 = load double*, double** %13
%89 = load i32, i32* %20
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %88, i64 %90
%92 = load double, double* %91
%93 = fmul double %87, %92
%94 = load double*, double** %10
%95 = load i32, i32* %20
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %94, i64 %96
store double %93, double* %97
br label %98
98: ; preds = %80
%99 = load i32, i32* %20
%100 = add nsw i32 %99, 1
store i32 %100, i32* %20
br label %76
101: ; preds = %76
br label %131
102: ; preds = %72
%103 = load i32, i32* %7
%104 = load double*, double** %9
%105 = load i32, i32* %22
%106 = load double*, double** %13
%107 = call i32 @Pmm_L2(i32 %103, double* %104, i32 %105, double* %106)
%108 = load double*, double** %8
%109 = getelementptr inbounds double, double* %108, i64 0
%110 = load double, double* %109
store double %110, double* %23
store i32 0, i32* %20
br label %111
111: ; preds = %127, %102
%112 = load i32, i32* %20
%113 = load i32, i32* %22
%114 = icmp slt i32 %112, %113
br i1 %114, label %115, label %130
115: ; preds = %111
%116 = load double, double* %23
%117 = load double*, double** %13
%118 = load i32, i32* %20
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %117, i64 %119
%121 = load double, double* %120
%122 = fmul double %116, %121
%123 = load double*, double** %10
%124 = load i32, i32* %20
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %123, i64 %125
store double %122, double* %126
br label %127
127: ; preds = %115
%128 = load i32, i32* %20
%129 = add nsw i32 %128, 1
store i32 %129, i32* %20
br label %111
130: ; preds = %111
br label %131
131: ; preds = %130, %101
store i32 0, i32* %20
br label %132
132: ; preds = %209, %131
%133 = load i32, i32* %20
%134 = load i32, i32* %12
%135 = load i32, i32* %7
%136 = sub nsw i32 %134, %135
%137 = sub nsw i32 %136, 1
%138 = icmp slt i32 %133, %137
br i1 %138, label %139, label %212
139: ; preds = %132
%140 = load i32, i32* %7
%141 = load i32, i32* %7
%142 = load i32, i32* %20
%143 = add nsw i32 %141, %142
%144 = call i32 @L2_cn(i32 %140, i32 %143)
%145 = load double*, double** %14
%146 = load double*, double** %15
%147 = load i32, i32* %22
%148 = call i32 @vec_mul(i32 %144, double* %145, double* %146, i32 %147)
%149 = load double*, double** %13
%150 = load double*, double** %19
%151 = load double*, double** %16
%152 = load i32, i32* %22
%153 = call i32 @vec_pt_mul(double* %149, double* %150, double* %151, i32 %152)
%154 = load i32, i32* %7
%155 = load i32, i32* %7
%156 = load i32, i32* %20
%157 = add nsw i32 %155, %156
%158 = call i32 @L2_an(i32 %154, i32 %157)
%159 = load double*, double** %16
%160 = load double*, double** %17
%161 = load i32, i32* %22
%162 = call i32 @vec_mul(i32 %158, double* %159, double* %160, i32 %161)
%163 = load double*, double** %17
%164 = load double*, double** %15
%165 = load double*, double** %18
%166 = load i32, i32* %22
%167 = call i32 @vec_add(double* %163, double* %164, double* %165, i32 %166)
%168 = load double*, double** %8
%169 = load i32, i32* %20
%170 = add nsw i32 %169, 1
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %168, i64 %171
%173 = load double, double* %172
store double %173, double* %23
store i32 0, i32* %21
br label %174
174: ; preds = %191, %139
%175 = load i32, i32* %21
%176 = load i32, i32* %22
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %194
178: ; preds = %174
%179 = load double, double* %23
%180 = load double*, double** %18
%181 = load i32, i32* %21
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds double, double* %180, i64 %182
%184 = load double, double* %183
%185 = load double*, double** %10
%186 = load i32, i32* %21
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %185, i64 %187
%189 = load double, double* %188
%190 = call double @llvm.fmuladd.f64(double %179, double %184, double %189)
store double %190, double* %188
br label %191
191: ; preds = %178
%192 = load i32, i32* %21
%193 = add nsw i32 %192, 1
store i32 %193, i32* %21
br label %174
194: ; preds = %174
%195 = load double*, double** %14
%196 = load double*, double** %13
%197 = load i32, i32* %22
%198 = sext i32 %197 to i64
%199 = mul i64 8, %198
%200 = trunc i64 %199 to i32
%201 = call i32 @memcpy(double* %195, double* %196, i32 %200)
%202 = load double*, double** %13
%203 = load double*, double** %18
%204 = load i32, i32* %22
%205 = sext i32 %204 to i64
%206 = mul i64 8, %205
%207 = trunc i64 %206 to i32
%208 = call i32 @memcpy(double* %202, double* %203, i32 %207)
br label %209
209: ; preds = %194
%210 = load i32, i32* %20
%211 = add nsw i32 %210, 1
store i32 %211, i32* %20
br label %132
212: ; preds = %132
ret void
}

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