void lagrange_eval(double *restrict p, double *restrict data, unsigned n,
                   int der, double x) {
  {
    unsigned i;
    const double *restrict z = data, *restrict w = z + n;
    double *restrict d = data + 2 * n, *restrict u0 = d + n,
                     *restrict v0 = u0 + n;
    for (i = 0; i < n; ++i)
      d[i] = 2 * (x - z[i]);
    u0[0] = 1;
    for (i = 0; i < n - 1; ++i)
      u0[i + 1] = u0[i] * d[i];
    v0[n - 1] = 1;
    for (i = n - 1; i; --i)
      v0[i - 1] = d[i] * v0[i];
    for (i = 0; i < n; ++i)
      p[i] = w[i] * u0[i] * v0[i];
    if (der > 0) {
      double *restrict p1 = p + n, *restrict u1 = v0 + n, *restrict v1 = u1 + n;
      u1[0] = 0;
      for (i = 0; i < n - 1; ++i)
        u1[i + 1] = u1[i] * d[i] + u0[i];
      v1[n - 1] = 0;
      for (i = n - 1; i; --i)
        v1[i - 1] = d[i] * v1[i] + v0[i];
      for (i = 0; i < n; ++i)
        p1[i] = 2 * w[i] * (u1[i] * v0[i] + u0[i] * v1[i]);
      if (der > 1) {
        double *restrict p2 = p1 + n, *restrict u2 = v1 + n,
                         *restrict v2 = u2 + n;
        u2[0] = 0;
        for (i = 0; i < n - 1; ++i)
          u2[i + 1] = u2[i] * d[i] + 2 * u1[i];
        v2[n - 1] = 0;
        for (i = n - 1; i; --i)
          v2[i - 1] = d[i] * v2[i] + 2 * v1[i];
        for (i = 0; i < n; ++i)
          p2[i] =
              4 * w[i] * (u2[i] * v0[i] + 2 * u1[i] * v1[i] + u0[i] * v2[i]);
      }
    }
  }
}


x86 assembly (clang, -O0):
<lagrange_eval>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    %ecx,%ecx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    11b6 <lagrange_eval+0xb6>
movsd  -0x20(%rbp),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
subsd  (%rax,%rcx,8),%xmm1
movsd  0xe70(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1173 <lagrange_eval+0x73>
mov    -0x48(%rbp),%rax
movsd  0xe3e(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    1215 <lagrange_eval+0x115>
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11cd <lagrange_eval+0xcd>
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movsd  0xdd7(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1278 <lagrange_eval+0x178>
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1237 <lagrange_eval+0x137>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    12c9 <lagrange_eval+0x1c9>
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    127f <lagrange_eval+0x17f>
cmpl   $0x0,-0x18(%rbp)
jle    1645 <lagrange_eval+0x545>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    1377 <lagrange_eval+0x277>
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    131b <lagrange_eval+0x21b>
mov    -0x68(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     13e9 <lagrange_eval+0x2e9>
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1394 <lagrange_eval+0x294>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1466 <lagrange_eval+0x366>
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  0xbfd(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x68(%rbp),%rax
mov    -0x24(%rbp),%ecx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13f0 <lagrange_eval+0x2f0>
cmpl   $0x1,-0x18(%rbp)
jle    1640 <lagrange_eval+0x540>
mov    -0x58(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    151c <lagrange_eval+0x41c>
mov    -0x78(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  0xb18(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x78(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14b8 <lagrange_eval+0x3b8>
mov    -0x80(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1596 <lagrange_eval+0x496>
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x68(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  0xa9e(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1539 <lagrange_eval+0x439>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    163b <lagrange_eval+0x53b>
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  0xa58(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  0xa24(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
mov    -0x24(%rbp),%ecx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x80(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    159d <lagrange_eval+0x49d>
jmp    1640 <lagrange_eval+0x540>
jmp    1645 <lagrange_eval+0x545>
pop    %rbp
ret

x86 assembly (clang, -O2):
<lagrange_eval>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %ecx,-0x24(%rsp)
mov    %edx,%r14d
lea    (%rsi,%r14,8),%rax
lea    (%rdx,%rdx,1),%r13d
lea    (%rsi,%r13,8),%r10
lea    (%r10,%r14,8),%r9
lea    (%r9,%r14,8),%r8
movabs $0x3ff0000000000000,%r15
test   %edx,%edx
mov    %rax,-0x10(%rsp)
mov    %r8,-0x38(%rsp)
mov    %rdx,-0x30(%rsp)
mov    %r9,-0x18(%rsp)
je     120d <lagrange_eval+0x10d>
cmp    $0x4,%edx
jb     116a <lagrange_eval+0x6a>
cmp    %rax,%r10
jae    121a <lagrange_eval+0x11a>
lea    (%r14,%r13,1),%rax
lea    (%rsi,%rax,8),%rax
cmp    %rsi,%rax
jbe    121a <lagrange_eval+0x11a>
xor    %eax,%eax
mov    %rax,%rbx
not    %rbx
add    %r14,%rbx
mov    %r14,%rbp
and    $0x3,%rbp
je     119d <lagrange_eval+0x9d>
xchg   %ax,%ax
movapd %xmm0,%xmm1
subsd  (%rsi,%rax,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r10,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
jne    1180 <lagrange_eval+0x80>
cmp    $0x3,%rbx
jb     1311 <lagrange_eval+0x211>
lea    (%rsi,%r13,8),%rbp
add    $0x18,%rbp
nop
movapd %xmm0,%xmm1
subsd  (%rsi,%rax,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,-0x18(%rbp,%rax,8)
movapd %xmm0,%xmm1
subsd  0x8(%rsi,%rax,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,-0x10(%rbp,%rax,8)
movapd %xmm0,%xmm1
subsd  0x10(%rsi,%rax,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,-0x8(%rbp,%rax,8)
movapd %xmm0,%xmm1
subsd  0x18(%rsi,%rax,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    11b0 <lagrange_eval+0xb0>
jmp    1311 <lagrange_eval+0x211>
mov    %r15,(%r9)
mov    $0xffffffff,%eax
jmp    131f <lagrange_eval+0x21f>
mov    %r14d,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rax),%rdx
mov    %rdx,%r12
shr    $0x2,%r12
add    $0x1,%r12
test   %rdx,%rdx
je     1c73 <lagrange_eval+0xb73>
mov    %r12,%rdx
and    $0xfffffffffffffffe,%rdx
lea    0x30(%rsi),%r8
lea    (%rsi,%r13,8),%rbx
add    $0x30,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x30(%r8,%rbp,8),%xmm2
movupd -0x20(%r8,%rbp,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
addpd  %xmm4,%xmm4
addpd  %xmm2,%xmm2
movupd %xmm4,-0x30(%rbx,%rbp,8)
movupd %xmm2,-0x20(%rbx,%rbp,8)
movupd -0x10(%r8,%rbp,8),%xmm2
movupd (%r8,%rbp,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
addpd  %xmm4,%xmm4
addpd  %xmm2,%xmm2
movupd %xmm4,-0x10(%rbx,%rbp,8)
movupd %xmm2,(%rbx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1260 <lagrange_eval+0x160>
test   $0x1,%r12b
je     12fe <lagrange_eval+0x1fe>
movupd (%rsi,%rbp,8),%xmm2
movupd 0x10(%rsi,%rbp,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
subpd  %xmm3,%xmm1
addpd  %xmm4,%xmm4
addpd  %xmm1,%xmm1
movupd %xmm4,(%r10,%rbp,8)
movupd %xmm1,0x10(%r10,%rbp,8)
cmp    %r14,%rax
mov    -0x38(%rsp),%r8
mov    -0x30(%rsp),%rdx
jne    116c <lagrange_eval+0x6c>
mov    %r15,(%r9)
mov    %edx,%eax
add    $0xffffffff,%eax
je     14c3 <lagrange_eval+0x3c3>
mov    %eax,%r9d
lea    -0x1(%r9),%r12
mov    %r9d,%r8d
and    $0x3,%r8d
cmp    $0x3,%r12
jae    133f <lagrange_eval+0x23f>
movsd  0xcc5(%rip),%xmm0
xor    %edx,%edx
jmp    13a7 <lagrange_eval+0x2a7>
mov    %r9d,%ebp
and    $0xfffffffc,%ebp
lea    (%r14,%r13,1),%rax
lea    (%rsi,%rax,8),%rbx
add    $0x20,%rbx
lea    (%rsi,%r13,8),%rax
add    $0x18,%rax
movsd  0xc9f(%rip),%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulsd  -0x18(%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x18(%rbx,%rdx,8)
mulsd  -0x10(%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x10(%rbx,%rdx,8)
mulsd  -0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rdx,8)
mulsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    1370 <lagrange_eval+0x270>
test   %r8,%r8
je     13e3 <lagrange_eval+0x2e3>
lea    (%rdx,%r14,1),%rax
add    %r13,%rax
lea    (%rsi,%rax,8),%rax
add    $0x8,%rax
add    %r13,%rdx
lea    (%rsi,%rdx,8),%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mulsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r8
jne    13d0 <lagrange_eval+0x2d0>
mov    -0x38(%rsp),%rax
mov    %r15,(%rax,%r9,8)
mov    %r9,%rdx
and    $0x3,%rdx
je     144e <lagrange_eval+0x34e>
lea    0x0(,%r14,2),%rax
add    %r13,%rax
lea    (%rsi,%rax,8),%rbp
add    $0xfffffffffffffff8,%rbp
movsd  0xbf0(%rip),%xmm0
mov    %r9,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%rdx
jne    1420 <lagrange_eval+0x320>
cmp    $0x3,%r12
jae    145f <lagrange_eval+0x35f>
movl   $0x0,-0x44(%rsp)
mov    -0x30(%rsp),%rdx
jmp    14d2 <lagrange_eval+0x3d2>
movsd  0xbaa(%rip),%xmm0
mov    %r9,%rax
cmp    $0x3,%r12
jb     143c <lagrange_eval+0x33c>
lea    0x0(,%r14,2),%rdx
add    %r13,%rdx
lea    (%rsi,%rdx,8),%rbp
add    $0xfffffffffffffff8,%rbp
mov    -0x30(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
mulsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
mulsd  -0x8(%r10,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rax,8)
mulsd  -0x10(%r10,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rbp,%rax,8)
mulsd  -0x18(%r10,%rax,8),%xmm0
movsd  %xmm0,-0x18(%rbp,%rax,8)
add    $0xfffffffffffffffc,%rax
jne    1480 <lagrange_eval+0x380>
movl   $0x0,-0x44(%rsp)
jmp    14d2 <lagrange_eval+0x3d2>
mov    %eax,%eax
mov    %r15,(%r8,%rax,8)
mov    $0x1,%al
mov    %eax,-0x44(%rsp)
xor    %r9d,%r9d
test   %edx,%edx
mov    %r13,-0x40(%rsp)
je     1680 <lagrange_eval+0x580>
cmp    $0x4,%edx
jae    14ec <lagrange_eval+0x3ec>
xor    %r15d,%r15d
jmp    162f <lagrange_eval+0x52f>
mov    %r14d,%r15d
and    $0xfffffffc,%r15d
lea    -0x4(%r15),%rax
mov    %rax,%r12
shr    $0x2,%r12
add    $0x1,%r12
test   %rax,%rax
je     172f <lagrange_eval+0x62f>
mov    %r12,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rsi,%r14,8),%r13
add    $0x30,%r13
mov    -0x40(%rsp),%rdx
lea    (%r14,%rdx,1),%rax
lea    (%rsi,%rax,8),%rbx
add    $0x30,%rbx
lea    (%rdx,%r14,2),%rax
lea    (%rsi,%rax,8),%rdx
add    $0x30,%rdx
xor    %eax,%eax
nopl   0x0(%rax)
movupd -0x30(%r13,%rax,8),%xmm0
movupd -0x20(%r13,%rax,8),%xmm1
movupd -0x30(%rbx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rbx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd -0x30(%rdx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
movupd -0x20(%rdx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rdi,%rax,8)
movupd %xmm2,0x10(%rdi,%rax,8)
movupd -0x10(%r13,%rax,8),%xmm0
movupd 0x0(%r13,%rax,8),%xmm1
movupd -0x10(%rbx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rbx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd -0x10(%rdx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
movupd (%rdx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd %xmm1,0x20(%rdi,%rax,8)
movupd %xmm2,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    1540 <lagrange_eval+0x440>
test   $0x1,%r12b
je     1620 <lagrange_eval+0x520>
mov    -0x10(%rsp),%rdx
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
mov    -0x18(%rsp),%rdx
movupd (%rdx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
mov    -0x38(%rsp),%rdx
movupd (%rdx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
movupd 0x10(%rdx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rdi,%rax,8)
movupd %xmm2,0x10(%rdi,%rax,8)
cmp    %r14,%r15
mov    -0x40(%rsp),%r13
mov    -0x30(%rsp),%rdx
je     1680 <lagrange_eval+0x580>
lea    (%r15,%r14,1),%rax
lea    (%rsi,%rax,8),%r8
add    %r13,%rax
lea    (%rsi,%rax,8),%r11
lea    (%r15,%r14,2),%rax
add    %r13,%rax
lea    (%rsi,%rax,8),%r12
lea    (%rdi,%r15,8),%rbx
mov    %r14,%rax
sub    %r15,%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r8,%rbp,8),%xmm0
mulsd  (%r11,%rbp,8),%xmm0
mulsd  (%r12,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1660 <lagrange_eval+0x560>
cmpl   $0x0,-0x24(%rsp)
jle    1c68 <lagrange_eval+0xb68>
mov    -0x38(%rsp),%rax
lea    (%rax,%r14,8),%rbp
mov    %rbp,-0x20(%rsp)
lea    0x0(,%r14,8),%rcx
add    %rbp,%rcx
movq   $0x0,(%rax,%r14,8)
cmpb   $0x0,-0x44(%rsp)
mov    %rcx,-0x8(%rsp)
je     16c5 <lagrange_eval+0x5c5>
movq   $0x0,(%rcx,%r9,8)
jmp    17ea <lagrange_eval+0x6ea>
mov    %r9,%r8
add    $0xffffffffffffffff,%r8
mov    -0x40(%rsp),%r15
je     1740 <lagrange_eval+0x640>
mov    %r9d,%r11d
and    $0xfffffffe,%r11d
lea    (%r14,%r14,2),%rax
add    %r15,%rax
lea    (%rsi,%rax,8),%r12
add    $0x10,%r12
lea    0x8(%rsi,%r15,8),%rax
lea    (%r14,%r15,1),%rbx
lea    (%rsi,%rbx,8),%rbp
add    $0x8,%rbp
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
mulsd  -0x8(%rax,%rbx,8),%xmm0
addsd  -0x8(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rbx,8)
mulsd  (%rax,%rbx,8),%xmm0
addsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%r12,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r11
jne    1700 <lagrange_eval+0x600>
jmp    1746 <lagrange_eval+0x646>
xor    %eax,%eax
test   $0x1,%r12b
jne    15d5 <lagrange_eval+0x4d5>
jmp    1620 <lagrange_eval+0x520>
xor    %ebx,%ebx
xorpd  %xmm0,%xmm0
test   $0x1,%r9b
mov    -0x38(%rsp),%rbp
je     176c <lagrange_eval+0x66c>
mulsd  (%r10,%rbx,8),%xmm0
mov    -0x18(%rsp),%rax
addsd  (%rax,%rbx,8),%xmm0
mov    -0x20(%rsp),%rax
movsd  %xmm0,0x8(%rax,%rbx,8)
mov    -0x8(%rsp),%rax
movq   $0x0,(%rax,%r9,8)
cmpb   $0x0,-0x44(%rsp)
jne    17ea <lagrange_eval+0x6ea>
xorpd  %xmm0,%xmm0
mov    %r9,%rbx
test   $0x1,%r9b
je     17a8 <lagrange_eval+0x6a8>
xorpd  %xmm0,%xmm0
mulsd  (%r10,%r9,8),%xmm0
addsd  0x0(%rbp,%r9,8),%xmm0
movsd  %xmm0,-0x8(%rax,%r9,8)
mov    %r8,%rbx
test   %r8,%r8
je     17ea <lagrange_eval+0x6ea>
lea    (%r15,%r14,4),%rax
lea    (%rsi,%rax,8),%rax
add    $0xfffffffffffffff8,%rax
nopl   0x0(%rax)
mulsd  (%r10,%rbx,8),%xmm0
addsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
mulsd  -0x8(%r10,%rbx,8),%xmm0
addsd  -0x8(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rbx,8)
add    $0xfffffffffffffffe,%rbx
jne    17c0 <lagrange_eval+0x6c0>
test   %edx,%edx
je     1977 <lagrange_eval+0x877>
cmpl   $0x4,-0x30(%rsp)
jae    1801 <lagrange_eval+0x701>
xor    %r13d,%r13d
jmp    18e9 <lagrange_eval+0x7e9>
mov    %r14d,%r13d
and    $0xfffffffc,%r13d
lea    (%rsi,%r14,8),%rax
add    $0x10,%rax
lea    (%r14,%r14,2),%rdx
mov    -0x40(%rsp),%r8
add    %r8,%rdx
lea    (%rsi,%rdx,8),%rbp
add    $0x10,%rbp
lea    (%r8,%r14,2),%rdx
lea    0x10(%rsi,%rdx,8),%rbx
lea    (%r14,%r8,1),%rdx
lea    0x10(%rsi,%rdx,8),%r12
lea    (%r8,%r14,4),%rdx
lea    (%rsi,%rdx,8),%rdx
add    $0x10,%rdx
lea    (%rdi,%r14,8),%r8
add    $0x10,%r8
lea    0x0(,%r14,8),%r11
and    $0xffffffffffffffe0,%r11
xor    %r15d,%r15d
nopl   0x0(%rax)
movupd -0x10(%rax,%r15,1),%xmm0
movupd (%rax,%r15,1),%xmm1
addpd  %xmm0,%xmm0
addpd  %xmm1,%xmm1
movupd -0x10(%rbp,%r15,1),%xmm2
movupd 0x0(%rbp,%r15,1),%xmm3
movupd -0x10(%rbx,%r15,1),%xmm4
mulpd  %xmm2,%xmm4
movupd (%rbx,%r15,1),%xmm2
mulpd  %xmm3,%xmm2
movupd -0x10(%r12,%r15,1),%xmm3
movupd (%r12,%r15,1),%xmm5
movupd -0x10(%rdx,%r15,1),%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm4,%xmm6
mulpd  %xmm0,%xmm6
movupd (%rdx,%r15,1),%xmm0
mulpd  %xmm5,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm6,-0x10(%r8,%r15,1)
movupd %xmm0,(%r8,%r15,1)
add    $0x20,%r15
cmp    %r15,%r11
jne    1860 <lagrange_eval+0x760>
cmp    %r14,%r13
je     1977 <lagrange_eval+0x877>
lea    (%r14,%r13,1),%rdx
lea    (%rsi,%rdx,8),%r8
lea    (%r14,%r14,2),%rax
add    %r13,%rax
mov    -0x40(%rsp),%rbx
add    %rbx,%rax
lea    (%rsi,%rax,8),%r11
lea    0x0(,%r14,2),%rax
add    %r13,%rax
add    %rbx,%rax
lea    (%rsi,%rax,8),%r15
lea    (%rdx,%rbx,1),%rax
lea    (%rsi,%rax,8),%r12
lea    0x0(,%r14,4),%rax
add    %r13,%rax
add    %rbx,%rax
lea    (%rsi,%rax,8),%rax
lea    (%rdi,%rdx,8),%rdx
mov    %r14,%rbp
sub    %r13,%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  (%r8,%rbx,8),%xmm0
addsd  %xmm0,%xmm0
movsd  (%r12,%rbx,8),%xmm1
mulsd  (%rax,%rbx,8),%xmm1
movsd  (%r11,%rbx,8),%xmm2
mulsd  (%r15,%rbx,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rdx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1940 <lagrange_eval+0x840>
cmpl   $0x2,-0x24(%rsp)
mov    -0x30(%rsp),%r15
mov    -0x8(%rsp),%r12
jl     1c68 <lagrange_eval+0xb68>
lea    (%r12,%r14,8),%r11
lea    (%r11,%r14,8),%r13
movq   $0x0,(%r12,%r14,8)
cmpb   $0x0,-0x44(%rsp)
je     19b1 <lagrange_eval+0x8b1>
movq   $0x0,0x0(%r13,%r9,8)
jmp    1afd <lagrange_eval+0x9fd>
mov    %r9,%r8
add    $0xffffffffffffffff,%r8
je     1c84 <lagrange_eval+0xb84>
mov    %r9d,%edx
and    $0xfffffffe,%edx
lea    (%r14,%r14,4),%rax
mov    -0x40(%rsp),%rbp
add    %rbp,%rax
lea    (%rsi,%rax,8),%rbx
add    $0x10,%rbx
lea    (%rsi,%rbp,8),%rax
add    $0x8,%rax
lea    (%r14,%r14,2),%rcx
add    %rbp,%rcx
lea    (%rsi,%rcx,8),%rcx
add    $0x8,%rcx
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rcx,%rbp,8),%xmm1
addsd  %xmm1,%xmm1
mulsd  -0x8(%rax,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
movsd  (%rcx,%rbp,8),%xmm1
addsd  %xmm1,%xmm1
mulsd  (%rax,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rdx
jne    1a00 <lagrange_eval+0x900>
test   $0x1,%r9b
je     1a5f <lagrange_eval+0x95f>
mov    -0x20(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm1
addsd  %xmm1,%xmm1
mulsd  (%r10,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r11,%rbp,8)
movq   $0x0,0x0(%r13,%r9,8)
cmpb   $0x0,-0x44(%rsp)
jne    1afd <lagrange_eval+0x9fd>
xorpd  %xmm0,%xmm0
test   $0x1,%r9b
je     1a9f <lagrange_eval+0x99f>
movsd  (%r12,%r9,8),%xmm1
addsd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
mulsd  (%r10,%r9,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%r13,%r9,8)
mov    %r8,%r9
test   %r8,%r8
je     1afd <lagrange_eval+0x9fd>
lea    (%r14,%r14,2),%rax
mov    -0x40(%rsp),%rcx
lea    (%rcx,%rax,2),%rax
lea    (%rsi,%rax,8),%rax
add    $0xfffffffffffffff8,%rax
nopl   0x0(%rax)
movsd  (%r12,%r9,8),%xmm1
addsd  %xmm1,%xmm1
mulsd  (%r10,%r9,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%r9,8)
movsd  -0x8(%r12,%r9,8),%xmm1
mulsd  -0x8(%r10,%r9,8),%xmm0
addsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rax,%r9,8)
add    $0xfffffffffffffffe,%r9
jne    1ac0 <lagrange_eval+0x9c0>
test   %r15d,%r15d
je     1c68 <lagrange_eval+0xb68>
cmp    $0x1,%r15d
jne    1b14 <lagrange_eval+0xa14>
xor    %r8d,%r8d
jmp    1bb0 <lagrange_eval+0xab0>
lea    (%rdi,%r14,8),%rax
lea    (%rax,%r14,8),%r9
mov    %r14d,%r8d
and    $0xfffffffe,%r8d
xor    %edx,%edx
movapd 0x4e3(%rip),%xmm0
mov    -0x10(%rsp),%rcx
mov    -0x18(%rsp),%rbp
mov    -0x38(%rsp),%rbx
mov    -0x20(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rcx,%rdx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd (%r11,%rdx,8),%xmm2
movupd (%rbx,%rdx,8),%xmm3
mulpd  %xmm2,%xmm3
movupd (%rax,%rdx,8),%xmm2
addpd  %xmm2,%xmm2
movupd (%r12,%rdx,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd 0x0(%rbp,%rdx,8),%xmm2
movupd 0x0(%r13,%rdx,8),%xmm3
mulpd  %xmm2,%xmm3
addpd  %xmm4,%xmm3
mulpd  %xmm1,%xmm3
movupd %xmm3,(%r9,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r8
jne    1b50 <lagrange_eval+0xa50>
cmp    %r14,%r8
je     1c68 <lagrange_eval+0xb68>
lea    (%r8,%r14,1),%rcx
lea    (%rsi,%rcx,8),%r9
lea    (%r14,%r14,4),%rax
add    %r8,%rax
mov    -0x40(%rsp),%r15
add    %r15,%rax
lea    (%rsi,%rax,8),%r10
lea    (%r8,%r14,2),%r11
lea    (%r11,%r15,1),%rax
lea    (%rsi,%rax,8),%rbp
lea    (%r14,%r14,2),%rdx
lea    (%r8,%rdx,1),%rax
add    %r15,%rax
lea    (%rsi,%rax,8),%rbx
lea    (%r8,%r14,4),%rax
add    %r15,%rax
lea    (%rsi,%rax,8),%rax
add    %r15,%rcx
lea    (%rsi,%rcx,8),%rcx
lea    (%r8,%rdx,2),%rdx
add    %r15,%rdx
lea    (%rsi,%rdx,8),%rsi
lea    (%rdi,%r11,8),%rdi
sub    %r8,%r14
xor    %edx,%edx
movsd  0x3f4(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r9,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rbx,%rdx,8),%xmm2
addsd  %xmm2,%xmm2
mulsd  (%rax,%rdx,8),%xmm2
movsd  (%r10,%rdx,8),%xmm3
mulsd  0x0(%rbp,%rdx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  (%rcx,%rdx,8),%xmm2
mulsd  (%rsi,%rdx,8),%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    1c20 <lagrange_eval+0xb20>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
test   $0x1,%r12b
jne    12d2 <lagrange_eval+0x1d2>
jmp    12fe <lagrange_eval+0x1fe>
xor    %ebp,%ebp
xorpd  %xmm0,%xmm0
test   $0x1,%r9b
jne    1a40 <lagrange_eval+0x940>
jmp    1a5f <lagrange_eval+0x95f>

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

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