void CalcInterpolatedElements(const double t, double elem[], const int dim,
                              void (*calc_func)(const double t, double elem[]),
                              const double delta_t, double *t0, double e0[],
                              double *t1, double e1[], double *t2,
                              double e2[]) {
  int i;
  if (*t1 < -1e99) {
    *t0 = -1e100;
    *t2 = -1e100;
    *t1 = t;
    (*calc_func)(*t1, e1);
    for (i = 0; i < dim; i++)
      elem[i] = e1[i];
    return;
  }
  if (t <= *t1) {
    if (*t1 - delta_t <= t) {
      if (*t0 < -1e99) {
        *t0 = *t1 - delta_t;
        (*calc_func)(*t0, e0);
      }
    } else if (*t1 - 2.0 * delta_t <= t) {
      if (*t0 < -1e99) {
        *t0 = *t1 - delta_t;
        (*calc_func)(*t0, e0);
      }
      *t2 = *t1;
      *t1 = *t0;
      for (i = 0; i < dim; i++) {
        e2[i] = e1[i];
        e1[i] = e0[i];
      }
      *t0 = *t1 - delta_t;
      (*calc_func)(*t0, e0);
    } else {
      *t0 = -1e100;
      *t2 = -1e100;
      *t1 = t;
      (*calc_func)(*t1, e1);
      for (i = 0; i < dim; i++)
        elem[i] = e1[i];
      return;
    }
    {
      const double f0 = (*t1 - t);
      const double f1 = (t - *t0);
      const double fact = 1.0 / delta_t;
      for (i = 0; i < dim; i++)
        elem[i] = fact * (e0[i] * f0 + e1[i] * f1);
    }
  } else {
    if (*t1 + delta_t >= t) {
      if (*t2 < -1e99) {
        *t2 = *t1 + delta_t;
        (*calc_func)(*t2, e2);
      }
    } else if (*t1 + 2.0 * delta_t >= t) {
      if (*t2 < -1e99) {
        *t2 = *t1 + delta_t;
        (*calc_func)(*t2, e2);
      }
      *t0 = *t1;
      *t1 = *t2;
      for (i = 0; i < dim; i++) {
        e0[i] = e1[i];
        e1[i] = e2[i];
      }
      *t2 = *t1 + delta_t;
      (*calc_func)(*t2, e2);
    } else {
      *t0 = -1e100;
      *t2 = -1e100;
      *t1 = t;
      (*calc_func)(*t1, e1);
      for (i = 0; i < dim; i++)
        elem[i] = e1[i];
      return;
    }
    {
      const double f1 = (*t2 - t);
      const double f2 = (t - *t1);
      const double fact = 1.0 / delta_t;
      for (i = 0; i < dim; i++)
        elem[i] = fact * (e1[i] * f1 + e2[i] * f2);
    }
  }
}


x86 assembly (clang, -O0):
<CalcInterpolatedElements>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
movsd  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movsd  0xebc(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    11cd <CalcInterpolatedElements+0xcd>
mov    -0x30(%rbp),%rax
movsd  0xeae(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  0xe9e(%rip),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x8(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    0x10(%rbp),%rdi
call   *%rax
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11c8 <CalcInterpolatedElements+0xc8>
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1194 <CalcInterpolatedElements+0x94>
jmp    16e0 <CalcInterpolatedElements+0x5e0>
movsd  -0x8(%rbp),%xmm1
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1466 <CalcInterpolatedElements+0x366>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
subsd  -0x28(%rbp),%xmm1
movsd  -0x8(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1242 <CalcInterpolatedElements+0x142>
mov    -0x30(%rbp),%rax
movsd  0xdf4(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    123d <CalcInterpolatedElements+0x13d>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
subsd  -0x28(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    -0x38(%rbp),%rdi
call   *%rax
jmp    13c8 <CalcInterpolatedElements+0x2c8>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x28(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  -0x8(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1344 <CalcInterpolatedElements+0x244>
mov    -0x30(%rbp),%rax
movsd  0xd8e(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    12a3 <CalcInterpolatedElements+0x1a3>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
subsd  -0x28(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    -0x38(%rbp),%rdi
call   *%rax
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1318 <CalcInterpolatedElements+0x218>
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12ca <CalcInterpolatedElements+0x1ca>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
subsd  -0x28(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    -0x38(%rbp),%rdi
call   *%rax
jmp    13c3 <CalcInterpolatedElements+0x2c3>
mov    -0x30(%rbp),%rax
movsd  0xcb8(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  0xca8(%rip),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x8(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    0x10(%rbp),%rdi
call   *%rax
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13be <CalcInterpolatedElements+0x2be>
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    138a <CalcInterpolatedElements+0x28a>
jmp    16e0 <CalcInterpolatedElements+0x5e0>
jmp    13c8 <CalcInterpolatedElements+0x2c8>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
subsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x8(%rbp),%xmm0
mov    -0x30(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xc1c(%rip),%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1461 <CalcInterpolatedElements+0x361>
movsd  -0x60(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm3
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  -0x58(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1405 <CalcInterpolatedElements+0x305>
jmp    16e0 <CalcInterpolatedElements+0x5e0>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x28(%rbp),%xmm0
ucomisd -0x8(%rbp),%xmm0
jb     14c0 <CalcInterpolatedElements+0x3c0>
mov    0x18(%rbp),%rax
movsd  0xb76(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    14bb <CalcInterpolatedElements+0x3bb>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x28(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    0x20(%rbp),%rdi
call   *%rax
jmp    1642 <CalcInterpolatedElements+0x542>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x28(%rbp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd -0x8(%rbp),%xmm0
jb     15be <CalcInterpolatedElements+0x4be>
mov    0x18(%rbp),%rax
movsd  0xb14(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    151d <CalcInterpolatedElements+0x41d>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x28(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    0x20(%rbp),%rdi
call   *%rax
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1592 <CalcInterpolatedElements+0x492>
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1544 <CalcInterpolatedElements+0x444>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x28(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    0x20(%rbp),%rdi
call   *%rax
jmp    163d <CalcInterpolatedElements+0x53d>
mov    -0x30(%rbp),%rax
movsd  0xa3e(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  0xa2e(%rip),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x8(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    0x10(%rbp),%rdi
call   *%rax
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1638 <CalcInterpolatedElements+0x538>
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1604 <CalcInterpolatedElements+0x504>
jmp    16e0 <CalcInterpolatedElements+0x5e0>
jmp    1642 <CalcInterpolatedElements+0x542>
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
subsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x8(%rbp),%xmm0
mov    -0x40(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x9a2(%rip),%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16db <CalcInterpolatedElements+0x5db>
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x68(%rbp),%xmm3
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  -0x70(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    167f <CalcInterpolatedElements+0x57f>
jmp    16e0 <CalcInterpolatedElements+0x5e0>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CalcInterpolatedElements>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
movapd %xmm1,%xmm5
mov    %esi,%r13d
mov    %rdi,%rbx
movapd %xmm0,%xmm9
mov    0x78(%rsp),%rbp
mov    0x70(%rsp),%r14
movsd  (%r9),%xmm1
movsd  0xecc(%rip),%xmm2
ucomisd %xmm1,%xmm2
jbe    1200 <CalcInterpolatedElements+0x100>
movabs $0xd4b249ad2594c37d,%rax
49 b2 d4
mov    %rax,(%rcx)
mov    %rax,0x0(%rbp)
movsd  %xmm9,(%r9)
movapd %xmm9,%xmm0
mov    %r14,%rdi
call   *%rdx
test   %r13d,%r13d
jle    1f07 <CalcInterpolatedElements+0xe07>
mov    %r13d,%eax
cmp    $0x4,%r13d
jb     118a <CalcInterpolatedElements+0x8a>
lea    (%r14,%rax,8),%rcx
cmp    %rbx,%rcx
jbe    1421 <CalcInterpolatedElements+0x321>
lea    (%rbx,%rax,8),%rcx
cmp    %r14,%rcx
jbe    1421 <CalcInterpolatedElements+0x321>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     11b5 <CalcInterpolatedElements+0xb5>
xchg   %ax,%ax
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11a0 <CalcInterpolatedElements+0xa0>
cmp    $0x3,%rdx
jb     1f07 <CalcInterpolatedElements+0xe07>
nop
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x10(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  0x18(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    11c0 <CalcInterpolatedElements+0xc0>
jmp    1f07 <CalcInterpolatedElements+0xe07>
mov    %r8,%r15
mov    0x80(%rsp),%r12
movapd %xmm1,%xmm0
ucomisd %xmm9,%xmm1
jae    1300 <CalcInterpolatedElements+0x200>
addsd  %xmm5,%xmm0
ucomisd %xmm9,%xmm0
jae    13f0 <CalcInterpolatedElements+0x2f0>
movapd %xmm5,%xmm3
addsd  %xmm5,%xmm3
addsd  %xmm1,%xmm3
ucomisd %xmm9,%xmm3
jae    144b <CalcInterpolatedElements+0x34b>
movabs $0xd4b249ad2594c37d,%rax
49 b2 d4
mov    %rax,(%rcx)
mov    %rax,0x0(%rbp)
movsd  %xmm9,(%r9)
movapd %xmm9,%xmm0
mov    %r14,%rdi
call   *%rdx
test   %r13d,%r13d
jle    1f07 <CalcInterpolatedElements+0xe07>
mov    %r13d,%eax
cmp    $0x4,%r13d
jb     128c <CalcInterpolatedElements+0x18c>
lea    (%r14,%rax,8),%rcx
cmp    %rbx,%rcx
jbe    1812 <CalcInterpolatedElements+0x712>
lea    (%rbx,%rax,8),%rcx
cmp    %r14,%rcx
jbe    1812 <CalcInterpolatedElements+0x712>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     12b5 <CalcInterpolatedElements+0x1b5>
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    12a0 <CalcInterpolatedElements+0x1a0>
cmp    $0x3,%rdx
jb     1f07 <CalcInterpolatedElements+0xe07>
nop
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x10(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  0x18(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    12c0 <CalcInterpolatedElements+0x1c0>
jmp    1f07 <CalcInterpolatedElements+0xe07>
subsd  %xmm5,%xmm0
ucomisd %xmm0,%xmm9
jae    1409 <CalcInterpolatedElements+0x309>
movapd %xmm5,%xmm3
addsd  %xmm5,%xmm3
movapd %xmm1,%xmm4
subsd  %xmm3,%xmm4
ucomisd %xmm4,%xmm9
jae    14cb <CalcInterpolatedElements+0x3cb>
movabs $0xd4b249ad2594c37d,%rax
49 b2 d4
mov    %rax,(%rcx)
mov    %rax,0x0(%rbp)
movsd  %xmm9,(%r9)
movapd %xmm9,%xmm0
mov    %r14,%rdi
call   *%rdx
test   %r13d,%r13d
jle    1f07 <CalcInterpolatedElements+0xe07>
mov    %r13d,%eax
cmp    $0x4,%r13d
jb     1376 <CalcInterpolatedElements+0x276>
lea    (%r14,%rax,8),%rcx
cmp    %rbx,%rcx
jbe    1838 <CalcInterpolatedElements+0x738>
lea    (%rbx,%rax,8),%rcx
cmp    %r14,%rcx
jbe    1838 <CalcInterpolatedElements+0x738>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     13a5 <CalcInterpolatedElements+0x2a5>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1390 <CalcInterpolatedElements+0x290>
cmp    $0x3,%rdx
jb     1f07 <CalcInterpolatedElements+0xe07>
nop
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x10(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  0x18(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    13b0 <CalcInterpolatedElements+0x2b0>
jmp    1f07 <CalcInterpolatedElements+0xe07>
ucomisd 0x0(%rbp),%xmm2
ja     1ad6 <CalcInterpolatedElements+0x9d6>
test   %r13d,%r13d
jg     1b0f <CalcInterpolatedElements+0xa0f>
jmp    1f07 <CalcInterpolatedElements+0xe07>
ucomisd (%rcx),%xmm2
ja     1d36 <CalcInterpolatedElements+0xc36>
test   %r13d,%r13d
jg     1d74 <CalcInterpolatedElements+0xc74>
jmp    1f07 <CalcInterpolatedElements+0xe07>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    1549 <CalcInterpolatedElements+0x449>
xor    %edi,%edi
jmp    15b4 <CalcInterpolatedElements+0x4b4>
ucomisd 0x0(%rbp),%xmm2
jbe    14a0 <CalcInterpolatedElements+0x3a0>
movsd  %xmm0,0x0(%rbp)
mov    %r12,%rdi
movapd %xmm9,0x20(%rsp)
mov    %r13d,0x8(%rsp)
mov    %r9,0x18(%rsp)
movsd  %xmm5,0x10(%rsp)
mov    %rdx,%r13
mov    %rcx,%rbp
call   *%rdx
mov    %rbp,%rcx
mov    0x78(%rsp),%rbp
mov    %r13,%rdx
movsd  0x10(%rsp),%xmm5
mov    0x18(%rsp),%r9
mov    0x8(%rsp),%r13d
movapd 0x20(%rsp),%xmm9
movsd  (%r9),%xmm1
movsd  %xmm1,(%rcx)
movsd  0x0(%rbp),%xmm0
movsd  %xmm0,(%r9)
test   %r13d,%r13d
jle    1ad2 <CalcInterpolatedElements+0x9d2>
mov    %r13d,%eax
cmp    $0x4,%r13d
jae    15fd <CalcInterpolatedElements+0x4fd>
xor    %ecx,%ecx
jmp    1a5b <CalcInterpolatedElements+0x95b>
ucomisd (%rcx),%xmm2
jbe    151e <CalcInterpolatedElements+0x41e>
movsd  %xmm0,(%rcx)
mov    %r15,%rdi
movapd %xmm9,0x20(%rsp)
mov    %r13d,0x8(%rsp)
mov    %r9,0x18(%rsp)
movsd  %xmm5,0x10(%rsp)
mov    %rdx,%r13
mov    %rcx,%rbp
call   *%rdx
mov    %rbp,%rcx
mov    0x78(%rsp),%rbp
mov    %r13,%rdx
movsd  0x10(%rsp),%xmm5
mov    0x18(%rsp),%r9
mov    0x8(%rsp),%r13d
movapd 0x20(%rsp),%xmm9
movsd  (%r9),%xmm1
movsd  %xmm1,0x0(%rbp)
movsd  (%rcx),%xmm0
movsd  %xmm0,(%r9)
test   %r13d,%r13d
jle    1d32 <CalcInterpolatedElements+0xc32>
mov    %r13d,%eax
cmp    $0x4,%r13d
jae    1703 <CalcInterpolatedElements+0x603>
xor    %ebp,%ebp
jmp    1cbb <CalcInterpolatedElements+0xbbb>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nop
movups (%r14,%rdi,8),%xmm0
movups 0x10(%r14,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%r14,%rdi,8),%xmm0
movups 0x30(%r14,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%r14,%rdi,8),%xmm0
movups 0x50(%r14,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%r14,%rdi,8),%xmm0
movupd 0x70(%r14,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1550 <CalcInterpolatedElements+0x450>
test   %rdx,%rdx
je     15ef <CalcInterpolatedElements+0x4ef>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%r14,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nop
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    15d0 <CalcInterpolatedElements+0x4d0>
cmp    %rax,%rcx
je     1f07 <CalcInterpolatedElements+0xe07>
jmp    118c <CalcInterpolatedElements+0x8c>
mov    %rdx,0x8(%rsp)
mov    %r9,%rbp
lea    (%r14,%rax,8),%rcx
cmp    %r15,%rcx
seta   %r9b
lea    (%r15,%rax,8),%rsi
cmp    %r14,%rsi
seta   %r10b
lea    (%r12,%rax,8),%rdi
cmp    %r15,%rdi
seta   %dl
cmp    %r12,%rsi
seta   %r11b
cmp    %r14,%rdi
seta   %sil
cmp    %r12,%rcx
seta   %r8b
xor    %ecx,%ecx
test   %r10b,%r9b
jne    1a4e <CalcInterpolatedElements+0x94e>
and    %r11b,%dl
mov    %rbp,%r9
jne    1a51 <CalcInterpolatedElements+0x951>
and    %r8b,%sil
mov    0x8(%rsp),%rdx
mov    0x78(%rsp),%rbp
jne    1a5b <CalcInterpolatedElements+0x95b>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     19c6 <CalcInterpolatedElements+0x8c6>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
and    %r8,%rdi
xor    %esi,%esi
movups (%r14,%rsi,8),%xmm0
movups 0x10(%r14,%rsi,8),%xmm1
movups %xmm0,(%r15,%rsi,8)
movups %xmm1,0x10(%r15,%rsi,8)
movups (%r12,%rsi,8),%xmm0
movups 0x10(%r12,%rsi,8),%xmm1
movups %xmm0,(%r14,%rsi,8)
movups %xmm1,0x10(%r14,%rsi,8)
movups 0x20(%r14,%rsi,8),%xmm0
movups 0x30(%r14,%rsi,8),%xmm1
movups %xmm0,0x20(%r15,%rsi,8)
movups %xmm1,0x30(%r15,%rsi,8)
movupd 0x20(%r12,%rsi,8),%xmm0
movupd 0x30(%r12,%rsi,8),%xmm1
movupd %xmm0,0x20(%r14,%rsi,8)
movupd %xmm1,0x30(%r14,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1694 <CalcInterpolatedElements+0x594>
jmp    19c8 <CalcInterpolatedElements+0x8c8>
mov    %rcx,0x30(%rsp)
mov    %rdx,0x8(%rsp)
mov    %r9,0x18(%rsp)
lea    (%r14,%rax,8),%rcx
cmp    %r12,%rcx
seta   %r9b
lea    (%r12,%rax,8),%rsi
cmp    %r14,%rsi
seta   %r10b
lea    (%r15,%rax,8),%rdi
cmp    %r12,%rdi
seta   %dl
cmp    %r15,%rsi
seta   %r11b
cmp    %r14,%rdi
seta   %sil
cmp    %r15,%rcx
seta   %r8b
xor    %ebp,%ebp
test   %r10b,%r9b
jne    1cac <CalcInterpolatedElements+0xbac>
and    %r11b,%dl
mov    0x18(%rsp),%r9
jne    1cb1 <CalcInterpolatedElements+0xbb1>
and    %r8b,%sil
mov    0x8(%rsp),%rdx
mov    0x30(%rsp),%rcx
jne    1cbb <CalcInterpolatedElements+0xbbb>
mov    %eax,%ebp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1a08 <CalcInterpolatedElements+0x908>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
and    %r8,%rdi
xor    %esi,%esi
movups (%r14,%rsi,8),%xmm0
movups 0x10(%r14,%rsi,8),%xmm1
movups %xmm0,(%r12,%rsi,8)
movups %xmm1,0x10(%r12,%rsi,8)
movups (%r15,%rsi,8),%xmm0
movups 0x10(%r15,%rsi,8),%xmm1
movups %xmm0,(%r14,%rsi,8)
movups %xmm1,0x10(%r14,%rsi,8)
movups 0x20(%r14,%rsi,8),%xmm0
movups 0x30(%r14,%rsi,8),%xmm1
movups %xmm0,0x20(%r12,%rsi,8)
movups %xmm1,0x30(%r12,%rsi,8)
movupd 0x20(%r15,%rsi,8),%xmm0
movupd 0x30(%r15,%rsi,8),%xmm1
movupd %xmm0,0x20(%r14,%rsi,8)
movupd %xmm1,0x30(%r14,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    17a3 <CalcInterpolatedElements+0x6a3>
jmp    1a0a <CalcInterpolatedElements+0x90a>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    1862 <CalcInterpolatedElements+0x762>
xor    %edi,%edi
jmp    18cc <CalcInterpolatedElements+0x7cc>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    1914 <CalcInterpolatedElements+0x814>
xor    %edi,%edi
jmp    197e <CalcInterpolatedElements+0x87e>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
movups (%r14,%rdi,8),%xmm0
movups 0x10(%r14,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%r14,%rdi,8),%xmm0
movups 0x30(%r14,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%r14,%rdi,8),%xmm0
movups 0x50(%r14,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%r14,%rdi,8),%xmm0
movupd 0x70(%r14,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1868 <CalcInterpolatedElements+0x768>
test   %rdx,%rdx
je     1906 <CalcInterpolatedElements+0x806>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%r14,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    18e7 <CalcInterpolatedElements+0x7e7>
cmp    %rax,%rcx
je     1f07 <CalcInterpolatedElements+0xe07>
jmp    128e <CalcInterpolatedElements+0x18e>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
movups (%r14,%rdi,8),%xmm0
movups 0x10(%r14,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%r14,%rdi,8),%xmm0
movups 0x30(%r14,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%r14,%rdi,8),%xmm0
movups 0x50(%r14,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%r14,%rdi,8),%xmm0
movupd 0x70(%r14,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    191a <CalcInterpolatedElements+0x81a>
test   %rdx,%rdx
je     19b8 <CalcInterpolatedElements+0x8b8>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%r14,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1999 <CalcInterpolatedElements+0x899>
cmp    %rax,%rcx
je     1f07 <CalcInterpolatedElements+0xe07>
jmp    1378 <CalcInterpolatedElements+0x278>
xor    %esi,%esi
test   $0x1,%r8b
je     19fe <CalcInterpolatedElements+0x8fe>
movups (%r14,%rsi,8),%xmm0
movups 0x10(%r14,%rsi,8),%xmm1
movups %xmm0,(%r15,%rsi,8)
movups %xmm1,0x10(%r15,%rsi,8)
movupd (%r12,%rsi,8),%xmm0
movupd 0x10(%r12,%rsi,8),%xmm1
movupd %xmm0,(%r14,%rsi,8)
movupd %xmm1,0x10(%r14,%rsi,8)
cmp    %rax,%rcx
jne    1a5b <CalcInterpolatedElements+0x95b>
jmp    1acd <CalcInterpolatedElements+0x9cd>
xor    %esi,%esi
test   $0x1,%r8b
je     1a40 <CalcInterpolatedElements+0x940>
movups (%r14,%rsi,8),%xmm0
movups 0x10(%r14,%rsi,8),%xmm1
movups %xmm0,(%r12,%rsi,8)
movups %xmm1,0x10(%r12,%rsi,8)
movupd (%r15,%rsi,8),%xmm0
movupd 0x10(%r15,%rsi,8),%xmm1
movupd %xmm0,(%r14,%rsi,8)
movupd %xmm1,0x10(%r14,%rsi,8)
cmp    %rax,%rbp
jne    1cbb <CalcInterpolatedElements+0xbbb>
jmp    1d2d <CalcInterpolatedElements+0xc2d>
mov    %rbp,%r9
mov    0x8(%rsp),%rdx
mov    0x78(%rsp),%rbp
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     1a81 <CalcInterpolatedElements+0x981>
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
or     $0x1,%rcx
add    %rax,%rsi
je     1acd <CalcInterpolatedElements+0x9cd>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1a90 <CalcInterpolatedElements+0x990>
movsd  (%r9),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm5,0x10(%rsp)
movapd %xmm9,0x20(%rsp)
movsd  %xmm0,0x0(%rbp)
mov    %r12,%rdi
mov    %r13d,%r15d
mov    %r9,%r13
call   *%rdx
movsd  0x10(%rsp),%xmm5
mov    %r13,%r9
mov    %r15d,%r13d
movapd 0x20(%rsp),%xmm9
test   %r13d,%r13d
jle    1f07 <CalcInterpolatedElements+0xe07>
movsd  0x0(%rbp),%xmm8
subsd  %xmm9,%xmm8
subsd  (%r9),%xmm9
movsd  0x4e1(%rip),%xmm1
divsd  %xmm5,%xmm1
mov    %r13d,%eax
cmp    $0x4,%r13d
jae    1bd7 <CalcInterpolatedElements+0xad7>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     1b6b <CalcInterpolatedElements+0xa6b>
movsd  (%r12,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  (%r14,%rcx,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
or     $0x1,%rcx
add    %rax,%rdx
je     1f07 <CalcInterpolatedElements+0xe07>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r12,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  (%r14,%rcx,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  0x8(%r14,%rcx,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1b80 <CalcInterpolatedElements+0xa80>
jmp    1f07 <CalcInterpolatedElements+0xe07>
lea    (%rbx,%rax,8),%rcx
lea    (%r14,%rax,8),%rdx
cmp    %rbx,%rdx
seta   %dil
lea    (%r12,%rax,8),%rdx
cmp    %r14,%rcx
seta   %r8b
cmp    %rbx,%rdx
seta   %dl
cmp    %r12,%rcx
seta   %sil
xor    %ecx,%ecx
test   %r8b,%dil
jne    1b3a <CalcInterpolatedElements+0xa3a>
and    %sil,%dl
jne    1b3a <CalcInterpolatedElements+0xa3a>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm9,%xmm2
unpcklpd %xmm9,%xmm2
movapd %xmm8,%xmm3
unpcklpd %xmm8,%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
lea    0x0(,%rax,8),%rdx
and    $0xffffffffffffffe0,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%r14,%rsi,1),%xmm5
movupd 0x10(%r14,%rsi,1),%xmm6
movupd (%r12,%rsi,1),%xmm7
movupd 0x10(%r12,%rsi,1),%xmm0
mulpd  %xmm2,%xmm7
mulpd  %xmm2,%xmm0
mulpd  %xmm3,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm3,%xmm6
addpd  %xmm0,%xmm6
mulpd  %xmm4,%xmm5
mulpd  %xmm4,%xmm6
movupd %xmm5,(%rbx,%rsi,1)
movupd %xmm6,0x10(%rbx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    1c50 <CalcInterpolatedElements+0xb50>
cmp    %rax,%rcx
jne    1b3a <CalcInterpolatedElements+0xa3a>
jmp    1f07 <CalcInterpolatedElements+0xe07>
mov    0x18(%rsp),%r9
mov    0x8(%rsp),%rdx
mov    0x30(%rsp),%rcx
mov    %rbp,%rsi
not    %rsi
test   $0x1,%al
je     1ce1 <CalcInterpolatedElements+0xbe1>
movsd  (%r14,%rbp,8),%xmm0
movsd  %xmm0,(%r12,%rbp,8)
movsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r14,%rbp,8)
or     $0x1,%rbp
add    %rax,%rsi
je     1d2d <CalcInterpolatedElements+0xc2d>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rbp,8),%xmm0
movsd  %xmm0,(%r12,%rbp,8)
movsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r14,%rbp,8)
movsd  0x8(%r14,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r12,%rbp,8)
movsd  0x8(%r15,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r14,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rax
jne    1cf0 <CalcInterpolatedElements+0xbf0>
movsd  (%r9),%xmm0
subsd  %xmm5,%xmm0
movsd  %xmm5,0x10(%rsp)
movapd %xmm9,0x20(%rsp)
movsd  %xmm0,(%rcx)
mov    %r15,%rdi
mov    %r13d,%r12d
mov    %r9,%rbp
mov    %rcx,%r13
call   *%rdx
mov    %r13,%rcx
movsd  0x10(%rsp),%xmm5
mov    %rbp,%r9
mov    %r12d,%r13d
movapd 0x20(%rsp),%xmm9
test   %r13d,%r13d
jle    1f07 <CalcInterpolatedElements+0xe07>
movsd  (%r9),%xmm8
subsd  %xmm9,%xmm8
subsd  (%rcx),%xmm9
movsd  0x27d(%rip),%xmm1
divsd  %xmm5,%xmm1
mov    %r13d,%eax
cmp    $0x4,%r13d
jae    1e37 <CalcInterpolatedElements+0xd37>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     1dcf <CalcInterpolatedElements+0xccf>
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  (%r15,%rcx,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
or     $0x1,%rcx
add    %rax,%rdx
je     1f07 <CalcInterpolatedElements+0xe07>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  (%r15,%rcx,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  0x8(%r15,%rcx,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1de0 <CalcInterpolatedElements+0xce0>
jmp    1f07 <CalcInterpolatedElements+0xe07>
lea    (%rbx,%rax,8),%rcx
lea    (%r15,%rax,8),%rdx
cmp    %rbx,%rdx
seta   %dil
lea    (%r14,%rax,8),%rdx
cmp    %r15,%rcx
seta   %r8b
cmp    %rbx,%rdx
seta   %dl
cmp    %r14,%rcx
seta   %sil
xor    %ecx,%ecx
test   %r8b,%dil
jne    1d9e <CalcInterpolatedElements+0xc9e>
and    %sil,%dl
jne    1d9e <CalcInterpolatedElements+0xc9e>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm9,%xmm2
unpcklpd %xmm9,%xmm2
movapd %xmm8,%xmm3
unpcklpd %xmm8,%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
lea    0x0(,%rax,8),%rdx
and    $0xffffffffffffffe0,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%r15,%rsi,1),%xmm5
movupd 0x10(%r15,%rsi,1),%xmm6
movupd (%r14,%rsi,1),%xmm7
movupd 0x10(%r14,%rsi,1),%xmm0
mulpd  %xmm2,%xmm7
mulpd  %xmm2,%xmm0
mulpd  %xmm3,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm3,%xmm6
addpd  %xmm0,%xmm6
mulpd  %xmm4,%xmm5
mulpd  %xmm4,%xmm6
movupd %xmm5,(%rbx,%rsi,1)
movupd %xmm6,0x10(%rbx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    1eb0 <CalcInterpolatedElements+0xdb0>
cmp    %rax,%rcx
jne    1d9e <CalcInterpolatedElements+0xc9e>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @CalcInterpolatedElements(double %0, double* nocapture writeonly %1, i32 %2, void (double, double*)* nocapture %3, double %4, double* nocapture %5, double* %6, double* nocapture %7, double* %8, double* nocapture %9, double* %10) {
%12 = load double, double* %7
%13 = fcmp olt double %12, 0xD47D42AEA2879F2E
br i1 %13, label %14, label %141
14: ; preds = %11
store double -1.000000e+100, double* %5
store double -1.000000e+100, double* %9
store double %0, double* %7
tail call void %3(double %0, double* %8)
%15 = icmp sgt i32 %2, 0
br i1 %15, label %16, label %903
16: ; preds = %14
%17 = zext i32 %2 to i64
%18 = icmp ult i32 %2, 4
br i1 %18, label %104, label %19
19: ; preds = %16
%20 = getelementptr double, double* %1, i64 %17
%21 = getelementptr double, double* %8, i64 %17
%22 = icmp ugt double* %21, %1
%23 = icmp ugt double* %20, %8
%24 = and i1 %22, %23
br i1 %24, label %104, label %25
25: ; preds = %19
%26 = and i64 %17, 4294967292
%27 = add nsw i64 %26, -4
%28 = lshr exact i64 %27, 2
%29 = add nuw nsw i64 %28, 1
%30 = and i64 %29, 3
%31 = icmp ult i64 %27, 12
br i1 %31, label %83, label %32
32: ; preds = %25
%33 = and i64 %29, 9223372036854775804
br label %34
34: ; preds = %34, %32
%35 = phi i64 [ 0, %32 ], [ %80, %34 ]
%36 = phi i64 [ 0, %32 ], [ %81, %34 ]
%37 = getelementptr inbounds double, double* %8, i64 %35
%38 = bitcast double* %37 to <2 x double>*
%39 = load <2 x double>, <2 x double>* %38
%40 = getelementptr inbounds double, double* %37, i64 2
%41 = bitcast double* %40 to <2 x double>*
%42 = load <2 x double>, <2 x double>* %41
%43 = getelementptr inbounds double, double* %1, i64 %35
%44 = bitcast double* %43 to <2 x double>*
store <2 x double> %39, <2 x double>* %44
%45 = getelementptr inbounds double, double* %43, i64 2
%46 = bitcast double* %45 to <2 x double>*
store <2 x double> %42, <2 x double>* %46
%47 = or i64 %35, 4
%48 = getelementptr inbounds double, double* %8, i64 %47
%49 = bitcast double* %48 to <2 x double>*
%50 = load <2 x double>, <2 x double>* %49
%51 = getelementptr inbounds double, double* %48, i64 2
%52 = bitcast double* %51 to <2 x double>*
%53 = load <2 x double>, <2 x double>* %52
%54 = getelementptr inbounds double, double* %1, i64 %47
%55 = bitcast double* %54 to <2 x double>*
store <2 x double> %50, <2 x double>* %55
%56 = getelementptr inbounds double, double* %54, i64 2
%57 = bitcast double* %56 to <2 x double>*
store <2 x double> %53, <2 x double>* %57
%58 = or i64 %35, 8
%59 = getelementptr inbounds double, double* %8, i64 %58
%60 = bitcast double* %59 to <2 x double>*
%61 = load <2 x double>, <2 x double>* %60
%62 = getelementptr inbounds double, double* %59, i64 2
%63 = bitcast double* %62 to <2 x double>*
%64 = load <2 x double>, <2 x double>* %63
%65 = getelementptr inbounds double, double* %1, i64 %58
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> %61, <2 x double>* %66
%67 = getelementptr inbounds double, double* %65, i64 2
%68 = bitcast double* %67 to <2 x double>*
store <2 x double> %64, <2 x double>* %68
%69 = or i64 %35, 12
%70 = getelementptr inbounds double, double* %8, i64 %69
%71 = bitcast double* %70 to <2 x double>*
%72 = load <2 x double>, <2 x double>* %71
%73 = getelementptr inbounds double, double* %70, i64 2
%74 = bitcast double* %73 to <2 x double>*
%75 = load <2 x double>, <2 x double>* %74
%76 = getelementptr inbounds double, double* %1, i64 %69
%77 = bitcast double* %76 to <2 x double>*
store <2 x double> %72, <2 x double>* %77
%78 = getelementptr inbounds double, double* %76, i64 2
%79 = bitcast double* %78 to <2 x double>*
store <2 x double> %75, <2 x double>* %79
%80 = add nuw i64 %35, 16
%81 = add nuw i64 %36, 4
%82 = icmp eq i64 %81, %33
br i1 %82, label %83, label %34
83: ; preds = %34, %25
%84 = phi i64 [ 0, %25 ], [ %80, %34 ]
%85 = icmp eq i64 %30, 0
br i1 %85, label %102, label %86
86: ; preds = %83, %86
%87 = phi i64 [ %99, %86 ], [ %84, %83 ]
%88 = phi i64 [ %100, %86 ], [ 0, %83 ]
%89 = getelementptr inbounds double, double* %8, i64 %87
%90 = bitcast double* %89 to <2 x double>*
%91 = load <2 x double>, <2 x double>* %90
%92 = getelementptr inbounds double, double* %89, i64 2
%93 = bitcast double* %92 to <2 x double>*
%94 = load <2 x double>, <2 x double>* %93
%95 = getelementptr inbounds double, double* %1, i64 %87
%96 = bitcast double* %95 to <2 x double>*
store <2 x double> %91, <2 x double>* %96
%97 = getelementptr inbounds double, double* %95, i64 2
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> %94, <2 x double>* %98
%99 = add nuw i64 %87, 4
%100 = add i64 %88, 1
%101 = icmp eq i64 %100, %30
br i1 %101, label %102, label %86
102: ; preds = %86, %83
%103 = icmp eq i64 %26, %17
br i1 %103, label %903, label %104
104: ; preds = %19, %16, %102
%105 = phi i64 [ 0, %19 ], [ 0, %16 ], [ %26, %102 ]
%106 = xor i64 %105, -1
%107 = add nsw i64 %106, %17
%108 = and i64 %17, 3
%109 = icmp eq i64 %108, 0
br i1 %109, label %119, label %110
110: ; preds = %104, %110
%111 = phi i64 [ %116, %110 ], [ %105, %104 ]
%112 = phi i64 [ %117, %110 ], [ 0, %104 ]
%113 = getelementptr inbounds double, double* %8, i64 %111
%114 = load double, double* %113
%115 = getelementptr inbounds double, double* %1, i64 %111
store double %114, double* %115
%116 = add nuw nsw i64 %111, 1
%117 = add i64 %112, 1
%118 = icmp eq i64 %117, %108
br i1 %118, label %119, label %110
119: ; preds = %110, %104
%120 = phi i64 [ %105, %104 ], [ %116, %110 ]
%121 = icmp ult i64 %107, 3
br i1 %121, label %903, label %122
122: ; preds = %119, %122
%123 = phi i64 [ %139, %122 ], [ %120, %119 ]
%124 = getelementptr inbounds double, double* %8, i64 %123
%125 = load double, double* %124
%126 = getelementptr inbounds double, double* %1, i64 %123
store double %125, double* %126
%127 = add nuw nsw i64 %123, 1
%128 = getelementptr inbounds double, double* %8, i64 %127
%129 = load double, double* %128
%130 = getelementptr inbounds double, double* %1, i64 %127
store double %129, double* %130
%131 = add nuw nsw i64 %123, 2
%132 = getelementptr inbounds double, double* %8, i64 %131
%133 = load double, double* %132
%134 = getelementptr inbounds double, double* %1, i64 %131
store double %133, double* %134
%135 = add nuw nsw i64 %123, 3
%136 = getelementptr inbounds double, double* %8, i64 %135
%137 = load double, double* %136
%138 = getelementptr inbounds double, double* %1, i64 %135
store double %137, double* %138
%139 = add nuw nsw i64 %123, 4
%140 = icmp eq i64 %139, %17
br i1 %140, label %903, label %122
141: ; preds = %11
%142 = fcmp ult double %12, %0
br i1 %142, label %523, label %143
143: ; preds = %141
%144 = fsub double %12, %4
%145 = fcmp ugt double %144, %0
br i1 %145, label %149, label %146
146: ; preds = %143
%147 = load double, double* %5
%148 = fcmp olt double %147, 0xD47D42AEA2879F2E
br i1 %148, label %418, label %420
149: ; preds = %143
%150 = tail call double @llvm.fmuladd.f64(double %4, double -2.000000e+00, double %12)
%151 = fcmp ugt double %150, %0
br i1 %151, label %291, label %152
152: ; preds = %149
%153 = load double, double* %5
%154 = fcmp olt double %153, 0xD47D42AEA2879F2E
br i1 %154, label %155, label %157
155: ; preds = %152
store double %144, double* %5
tail call void %3(double %144, double* %6)
%156 = load double, double* %7
br label %157
157: ; preds = %155, %152
%158 = phi double [ %156, %155 ], [ %12, %152 ]
store double %158, double* %9
%159 = load double, double* %5
store double %159, double* %7
%160 = icmp sgt i32 %2, 0
br i1 %160, label %161, label %288
161: ; preds = %157
%162 = zext i32 %2 to i64
%163 = icmp ult i32 %2, 4
br i1 %163, label %255, label %164
164: ; preds = %161
%165 = getelementptr double, double* %10, i64 %162
%166 = getelementptr double, double* %8, i64 %162
%167 = getelementptr double, double* %6, i64 %162
%168 = icmp ugt double* %166, %10
%169 = icmp ugt double* %165, %8
%170 = and i1 %168, %169
%171 = icmp ugt double* %167, %10
%172 = icmp ugt double* %165, %6
%173 = and i1 %171, %172
%174 = or i1 %170, %173
%175 = icmp ugt double* %167, %8
%176 = icmp ugt double* %166, %6
%177 = and i1 %175, %176
%178 = or i1 %174, %177
br i1 %178, label %255, label %179
179: ; preds = %164
%180 = and i64 %162, 4294967292
%181 = add nsw i64 %180, -4
%182 = lshr exact i64 %181, 2
%183 = add nuw nsw i64 %182, 1
%184 = and i64 %183, 1
%185 = icmp eq i64 %181, 0
br i1 %185, label %231, label %186
186: ; preds = %179
%187 = and i64 %183, 9223372036854775806
br label %188
188: ; preds = %188, %186
%189 = phi i64 [ 0, %186 ], [ %228, %188 ]
%190 = phi i64 [ 0, %186 ], [ %229, %188 ]
%191 = getelementptr inbounds double, double* %8, i64 %189
%192 = bitcast double* %191 to <2 x double>*
%193 = load <2 x double>, <2 x double>* %192
%194 = getelementptr inbounds double, double* %191, i64 2
%195 = bitcast double* %194 to <2 x double>*
%196 = load <2 x double>, <2 x double>* %195
%197 = getelementptr inbounds double, double* %10, i64 %189
%198 = bitcast double* %197 to <2 x double>*
store <2 x double> %193, <2 x double>* %198
%199 = getelementptr inbounds double, double* %197, i64 2
%200 = bitcast double* %199 to <2 x double>*
store <2 x double> %196, <2 x double>* %200
%201 = getelementptr inbounds double, double* %6, i64 %189
%202 = bitcast double* %201 to <2 x double>*
%203 = load <2 x double>, <2 x double>* %202
%204 = getelementptr inbounds double, double* %201, i64 2
%205 = bitcast double* %204 to <2 x double>*
%206 = load <2 x double>, <2 x double>* %205
%207 = bitcast double* %191 to <2 x double>*
store <2 x double> %203, <2 x double>* %207
%208 = bitcast double* %194 to <2 x double>*
store <2 x double> %206, <2 x double>* %208
%209 = or i64 %189, 4
%210 = getelementptr inbounds double, double* %8, i64 %209
%211 = bitcast double* %210 to <2 x double>*
%212 = load <2 x double>, <2 x double>* %211
%213 = getelementptr inbounds double, double* %210, i64 2
%214 = bitcast double* %213 to <2 x double>*
%215 = load <2 x double>, <2 x double>* %214
%216 = getelementptr inbounds double, double* %10, i64 %209
%217 = bitcast double* %216 to <2 x double>*
store <2 x double> %212, <2 x double>* %217
%218 = getelementptr inbounds double, double* %216, i64 2
%219 = bitcast double* %218 to <2 x double>*
store <2 x double> %215, <2 x double>* %219
%220 = getelementptr inbounds double, double* %6, i64 %209
%221 = bitcast double* %220 to <2 x double>*
%222 = load <2 x double>, <2 x double>* %221
%223 = getelementptr inbounds double, double* %220, i64 2
%224 = bitcast double* %223 to <2 x double>*
%225 = load <2 x double>, <2 x double>* %224
%226 = bitcast double* %210 to <2 x double>*
store <2 x double> %222, <2 x double>* %226
%227 = bitcast double* %213 to <2 x double>*
store <2 x double> %225, <2 x double>* %227
%228 = add nuw i64 %189, 8
%229 = add i64 %190, 2
%230 = icmp eq i64 %229, %187
br i1 %230, label %231, label %188
231: ; preds = %188, %179
%232 = phi i64 [ 0, %179 ], [ %228, %188 ]
%233 = icmp eq i64 %184, 0
br i1 %233, label %253, label %234
234: ; preds = %231
%235 = getelementptr inbounds double, double* %8, i64 %232
%236 = bitcast double* %235 to <2 x double>*
%237 = load <2 x double>, <2 x double>* %236
%238 = getelementptr inbounds double, double* %235, i64 2
%239 = bitcast double* %238 to <2 x double>*
%240 = load <2 x double>, <2 x double>* %239
%241 = getelementptr inbounds double, double* %10, i64 %232
%242 = bitcast double* %241 to <2 x double>*
store <2 x double> %237, <2 x double>* %242
%243 = getelementptr inbounds double, double* %241, i64 2
%244 = bitcast double* %243 to <2 x double>*
store <2 x double> %240, <2 x double>* %244
%245 = getelementptr inbounds double, double* %6, i64 %232
%246 = bitcast double* %245 to <2 x double>*
%247 = load <2 x double>, <2 x double>* %246
%248 = getelementptr inbounds double, double* %245, i64 2
%249 = bitcast double* %248 to <2 x double>*
%250 = load <2 x double>, <2 x double>* %249
%251 = bitcast double* %235 to <2 x double>*
store <2 x double> %247, <2 x double>* %251
%252 = bitcast double* %238 to <2 x double>*
store <2 x double> %250, <2 x double>* %252
br label %253
253: ; preds = %231, %234
%254 = icmp eq i64 %180, %162
br i1 %254, label %286, label %255
255: ; preds = %164, %161, %253
%256 = phi i64 [ 0, %164 ], [ 0, %161 ], [ %180, %253 ]
%257 = xor i64 %256, -1
%258 = and i64 %162, 1
%259 = icmp eq i64 %258, 0
br i1 %259, label %267, label %260
260: ; preds = %255
%261 = getelementptr inbounds double, double* %8, i64 %256
%262 = load double, double* %261
%263 = getelementptr inbounds double, double* %10, i64 %256
store double %262, double* %263
%264 = getelementptr inbounds double, double* %6, i64 %256
%265 = load double, double* %264
store double %265, double* %261
%266 = or i64 %256, 1
br label %267
267: ; preds = %260, %255
%268 = phi i64 [ %256, %255 ], [ %266, %260 ]
%269 = sub nsw i64 0, %162
%270 = icmp eq i64 %257, %269
br i1 %270, label %286, label %271
271: ; preds = %267, %271
%272 = phi i64 [ %284, %271 ], [ %268, %267 ]
%273 = getelementptr inbounds double, double* %8, i64 %272
%274 = load double, double* %273
%275 = getelementptr inbounds double, double* %10, i64 %272
store double %274, double* %275
%276 = getelementptr inbounds double, double* %6, i64 %272
%277 = load double, double* %276
store double %277, double* %273
%278 = add nuw nsw i64 %272, 1
%279 = getelementptr inbounds double, double* %8, i64 %278
%280 = load double, double* %279
%281 = getelementptr inbounds double, double* %10, i64 %278
store double %280, double* %281
%282 = getelementptr inbounds double, double* %6, i64 %278
%283 = load double, double* %282
store double %283, double* %279
%284 = add nuw nsw i64 %272, 2
%285 = icmp eq i64 %284, %162
br i1 %285, label %286, label %271
286: ; preds = %267, %271, %253
%287 = load double, double* %7
br label %288
288: ; preds = %286, %157
%289 = phi double [ %287, %286 ], [ %159, %157 ]
%290 = fsub double %289, %4
br label %418
291: ; preds = %149
store double -1.000000e+100, double* %5
store double -1.000000e+100, double* %9
store double %0, double* %7
tail call void %3(double %0, double* %8)
%292 = icmp sgt i32 %2, 0
br i1 %292, label %293, label %903
293: ; preds = %291
%294 = zext i32 %2 to i64
%295 = icmp ult i32 %2, 4
br i1 %295, label %381, label %296
296: ; preds = %293
%297 = getelementptr double, double* %1, i64 %294
%298 = getelementptr double, double* %8, i64 %294
%299 = icmp ugt double* %298, %1
%300 = icmp ugt double* %297, %8
%301 = and i1 %299, %300
br i1 %301, label %381, label %302
302: ; preds = %296
%303 = and i64 %294, 4294967292
%304 = add nsw i64 %303, -4
%305 = lshr exact i64 %304, 2
%306 = add nuw nsw i64 %305, 1
%307 = and i64 %306, 3
%308 = icmp ult i64 %304, 12
br i1 %308, label %360, label %309
309: ; preds = %302
%310 = and i64 %306, 9223372036854775804
br label %311
311: ; preds = %311, %309
%312 = phi i64 [ 0, %309 ], [ %357, %311 ]
%313 = phi i64 [ 0, %309 ], [ %358, %311 ]
%314 = getelementptr inbounds double, double* %8, i64 %312
%315 = bitcast double* %314 to <2 x double>*
%316 = load <2 x double>, <2 x double>* %315
%317 = getelementptr inbounds double, double* %314, i64 2
%318 = bitcast double* %317 to <2 x double>*
%319 = load <2 x double>, <2 x double>* %318
%320 = getelementptr inbounds double, double* %1, i64 %312
%321 = bitcast double* %320 to <2 x double>*
store <2 x double> %316, <2 x double>* %321
%322 = getelementptr inbounds double, double* %320, i64 2
%323 = bitcast double* %322 to <2 x double>*
store <2 x double> %319, <2 x double>* %323
%324 = or i64 %312, 4
%325 = getelementptr inbounds double, double* %8, i64 %324
%326 = bitcast double* %325 to <2 x double>*
%327 = load <2 x double>, <2 x double>* %326
%328 = getelementptr inbounds double, double* %325, i64 2
%329 = bitcast double* %328 to <2 x double>*
%330 = load <2 x double>, <2 x double>* %329
%331 = getelementptr inbounds double, double* %1, i64 %324
%332 = bitcast double* %331 to <2 x double>*
store <2 x double> %327, <2 x double>* %332
%333 = getelementptr inbounds double, double* %331, i64 2
%334 = bitcast double* %333 to <2 x double>*
store <2 x double> %330, <2 x double>* %334
%335 = or i64 %312, 8
%336 = getelementptr inbounds double, double* %8, i64 %335
%337 = bitcast double* %336 to <2 x double>*
%338 = load <2 x double>, <2 x double>* %337
%339 = getelementptr inbounds double, double* %336, i64 2
%340 = bitcast double* %339 to <2 x double>*
%341 = load <2 x double>, <2 x double>* %340
%342 = getelementptr inbounds double, double* %1, i64 %335
%343 = bitcast double* %342 to <2 x double>*
store <2 x double> %338, <2 x double>* %343
%344 = getelementptr inbounds double, double* %342, i64 2
%345 = bitcast double* %344 to <2 x double>*
store <2 x double> %341, <2 x double>* %345
%346 = or i64 %312, 12
%347 = getelementptr inbounds double, double* %8, i64 %346
%348 = bitcast double* %347 to <2 x double>*
%349 = load <2 x double>, <2 x double>* %348
%350 = getelementptr inbounds double, double* %347, i64 2
%351 = bitcast double* %350 to <2 x double>*
%352 = load <2 x double>, <2 x double>* %351
%353 = getelementptr inbounds double, double* %1, i64 %346
%354 = bitcast double* %353 to <2 x double>*
store <2 x double> %349, <2 x double>* %354
%355 = getelementptr inbounds double, double* %353, i64 2
%356 = bitcast double* %355 to <2 x double>*
store <2 x double> %352, <2 x double>* %356
%357 = add nuw i64 %312, 16
%358 = add nuw i64 %313, 4
%359 = icmp eq i64 %358, %310
br i1 %359, label %360, label %311
360: ; preds = %311, %302
%361 = phi i64 [ 0, %302 ], [ %357, %311 ]
%362 = icmp eq i64 %307, 0
br i1 %362, label %379, label %363
363: ; preds = %360, %363
%364 = phi i64 [ %376, %363 ], [ %361, %360 ]
%365 = phi i64 [ %377, %363 ], [ 0, %360 ]
%366 = getelementptr inbounds double, double* %8, i64 %364
%367 = bitcast double* %366 to <2 x double>*
%368 = load <2 x double>, <2 x double>* %367
%369 = getelementptr inbounds double, double* %366, i64 2
%370 = bitcast double* %369 to <2 x double>*
%371 = load <2 x double>, <2 x double>* %370
%372 = getelementptr inbounds double, double* %1, i64 %364
%373 = bitcast double* %372 to <2 x double>*
store <2 x double> %368, <2 x double>* %373
%374 = getelementptr inbounds double, double* %372, i64 2
%375 = bitcast double* %374 to <2 x double>*
store <2 x double> %371, <2 x double>* %375
%376 = add nuw i64 %364, 4
%377 = add i64 %365, 1
%378 = icmp eq i64 %377, %307
br i1 %378, label %379, label %363
379: ; preds = %363, %360
%380 = icmp eq i64 %303, %294
br i1 %380, label %903, label %381
381: ; preds = %296, %293, %379
%382 = phi i64 [ 0, %296 ], [ 0, %293 ], [ %303, %379 ]
%383 = xor i64 %382, -1
%384 = add nsw i64 %383, %294
%385 = and i64 %294, 3
%386 = icmp eq i64 %385, 0
br i1 %386, label %396, label %387
387: ; preds = %381, %387
%388 = phi i64 [ %393, %387 ], [ %382, %381 ]
%389 = phi i64 [ %394, %387 ], [ 0, %381 ]
%390 = getelementptr inbounds double, double* %8, i64 %388
%391 = load double, double* %390
%392 = getelementptr inbounds double, double* %1, i64 %388
store double %391, double* %392
%393 = add nuw nsw i64 %388, 1
%394 = add i64 %389, 1
%395 = icmp eq i64 %394, %385
br i1 %395, label %396, label %387
396: ; preds = %387, %381
%397 = phi i64 [ %382, %381 ], [ %393, %387 ]
%398 = icmp ult i64 %384, 3
br i1 %398, label %903, label %399
399: ; preds = %396, %399
%400 = phi i64 [ %416, %399 ], [ %397, %396 ]
%401 = getelementptr inbounds double, double* %8, i64 %400
%402 = load double, double* %401
%403 = getelementptr inbounds double, double* %1, i64 %400
store double %402, double* %403
%404 = add nuw nsw i64 %400, 1
%405 = getelementptr inbounds double, double* %8, i64 %404
%406 = load double, double* %405
%407 = getelementptr inbounds double, double* %1, i64 %404
store double %406, double* %407
%408 = add nuw nsw i64 %400, 2
%409 = getelementptr inbounds double, double* %8, i64 %408
%410 = load double, double* %409
%411 = getelementptr inbounds double, double* %1, i64 %408
store double %410, double* %411
%412 = add nuw nsw i64 %400, 3
%413 = getelementptr inbounds double, double* %8, i64 %412
%414 = load double, double* %413
%415 = getelementptr inbounds double, double* %1, i64 %412
store double %414, double* %415
%416 = add nuw nsw i64 %400, 4
%417 = icmp eq i64 %416, %294
br i1 %417, label %903, label %399
418: ; preds = %146, %288
%419 = phi double [ %290, %288 ], [ %144, %146 ]
store double %419, double* %5
tail call void %3(double %419, double* %6)
br label %420
420: ; preds = %418, %146
%421 = load double, double* %7
%422 = fsub double %421, %0
%423 = load double, double* %5
%424 = fsub double %0, %423
%425 = fdiv double 1.000000e+00, %4
%426 = icmp sgt i32 %2, 0
br i1 %426, label %427, label %903
427: ; preds = %420
%428 = zext i32 %2 to i64
%429 = icmp ult i32 %2, 4
br i1 %429, label %483, label %430
430: ; preds = %427
%431 = getelementptr double, double* %1, i64 %428
%432 = getelementptr double, double* %6, i64 %428
%433 = getelementptr double, double* %8, i64 %428
%434 = icmp ugt double* %432, %1
%435 = icmp ugt double* %431, %6
%436 = and i1 %434, %435
%437 = icmp ugt double* %433, %1
%438 = icmp ugt double* %431, %8
%439 = and i1 %437, %438
%440 = or i1 %436, %439
br i1 %440, label %483, label %441
441: ; preds = %430
%442 = and i64 %428, 4294967292
%443 = insertelement <2 x double> poison, double %424, i64 0
%444 = shufflevector <2 x double> %443, <2 x double> poison, <2 x i32> zeroinitializer
%445 = insertelement <2 x double> poison, double %424, i64 0
%446 = shufflevector <2 x double> %445, <2 x double> poison, <2 x i32> zeroinitializer
%447 = insertelement <2 x double> poison, double %422, i64 0
%448 = shufflevector <2 x double> %447, <2 x double> poison, <2 x i32> zeroinitializer
%449 = insertelement <2 x double> poison, double %422, i64 0
%450 = shufflevector <2 x double> %449, <2 x double> poison, <2 x i32> zeroinitializer
%451 = insertelement <2 x double> poison, double %425, i64 0
%452 = shufflevector <2 x double> %451, <2 x double> poison, <2 x i32> zeroinitializer
%453 = insertelement <2 x double> poison, double %425, i64 0
%454 = shufflevector <2 x double> %453, <2 x double> poison, <2 x i32> zeroinitializer
br label %455
455: ; preds = %455, %441
%456 = phi i64 [ 0, %441 ], [ %479, %455 ]
%457 = getelementptr inbounds double, double* %6, i64 %456
%458 = bitcast double* %457 to <2 x double>*
%459 = load <2 x double>, <2 x double>* %458
%460 = getelementptr inbounds double, double* %457, i64 2
%461 = bitcast double* %460 to <2 x double>*
%462 = load <2 x double>, <2 x double>* %461
%463 = getelementptr inbounds double, double* %8, i64 %456
%464 = bitcast double* %463 to <2 x double>*
%465 = load <2 x double>, <2 x double>* %464
%466 = getelementptr inbounds double, double* %463, i64 2
%467 = bitcast double* %466 to <2 x double>*
%468 = load <2 x double>, <2 x double>* %467
%469 = fmul <2 x double> %444, %465
%470 = fmul <2 x double> %446, %468
%471 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %459, <2 x double> %448, <2 x double> %469)
%472 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %462, <2 x double> %450, <2 x double> %470)
%473 = fmul <2 x double> %452, %471
%474 = fmul <2 x double> %454, %472
%475 = getelementptr inbounds double, double* %1, i64 %456
%476 = bitcast double* %475 to <2 x double>*
store <2 x double> %473, <2 x double>* %476
%477 = getelementptr inbounds double, double* %475, i64 2
%478 = bitcast double* %477 to <2 x double>*
store <2 x double> %474, <2 x double>* %478
%479 = add nuw i64 %456, 4
%480 = icmp eq i64 %479, %442
br i1 %480, label %481, label %455
481: ; preds = %455
%482 = icmp eq i64 %442, %428
br i1 %482, label %903, label %483
483: ; preds = %430, %427, %481
%484 = phi i64 [ 0, %430 ], [ 0, %427 ], [ %442, %481 ]
%485 = xor i64 %484, -1
%486 = and i64 %428, 1
%487 = icmp eq i64 %486, 0
br i1 %487, label %498, label %488
488: ; preds = %483
%489 = getelementptr inbounds double, double* %6, i64 %484
%490 = load double, double* %489
%491 = getelementptr inbounds double, double* %8, i64 %484
%492 = load double, double* %491
%493 = fmul double %424, %492
%494 = tail call double @llvm.fmuladd.f64(double %490, double %422, double %493)
%495 = fmul double %425, %494
%496 = getelementptr inbounds double, double* %1, i64 %484
store double %495, double* %496
%497 = or i64 %484, 1
br label %498
498: ; preds = %488, %483
%499 = phi i64 [ %484, %483 ], [ %497, %488 ]
%500 = sub nsw i64 0, %428
%501 = icmp eq i64 %485, %500
br i1 %501, label %903, label %502
502: ; preds = %498, %502
%503 = phi i64 [ %521, %502 ], [ %499, %498 ]
%504 = getelementptr inbounds double, double* %6, i64 %503
%505 = load double, double* %504
%506 = getelementptr inbounds double, double* %8, i64 %503
%507 = load double, double* %506
%508 = fmul double %424, %507
%509 = tail call double @llvm.fmuladd.f64(double %505, double %422, double %508)
%510 = fmul double %425, %509
%511 = getelementptr inbounds double, double* %1, i64 %503
store double %510, double* %511
%512 = add nuw nsw i64 %503, 1
%513 = getelementptr inbounds double, double* %6, i64 %512
%514 = load double, double* %513
%515 = getelementptr inbounds double, double* %8, i64 %512
%516 = load double, double* %515
%517 = fmul double %424, %516
%518 = tail call double @llvm.fmuladd.f64(double %514, double %422, double %517)
%519 = fmul double %425, %518
%520 = getelementptr inbounds double, double* %1, i64 %512
store double %519, double* %520
%521 = add nuw nsw i64 %503, 2
%522 = icmp eq i64 %521, %428
br i1 %522, label %903, label %502
523: ; preds = %141
%524 = fadd double %12, %4
%525 = fcmp ult double %524, %0
br i1 %525, label %529, label %526
526: ; preds = %523
%527 = load double, double* %9
%528 = fcmp olt double %527, 0xD47D42AEA2879F2E
br i1 %528, label %798, label %800
529: ; preds = %523
%530 = tail call double @llvm.fmuladd.f64(double %4, double 2.000000e+00, double %12)
%531 = fcmp ult double %530, %0
br i1 %531, label %671, label %532
532: ; preds = %529
%533 = load double, double* %9
%534 = fcmp olt double %533, 0xD47D42AEA2879F2E
br i1 %534, label %535, label %537
535: ; preds = %532
store double %524, double* %9
tail call void %3(double %524, double* %10)
%536 = load double, double* %7
br label %537
537: ; preds = %535, %532
%538 = phi double [ %536, %535 ], [ %12, %532 ]
store double %538, double* %5
%539 = load double, double* %9
store double %539, double* %7
%540 = icmp sgt i32 %2, 0
br i1 %540, label %541, label %668
541: ; preds = %537
%542 = zext i32 %2 to i64
%543 = icmp ult i32 %2, 4
br i1 %543, label %635, label %544
544: ; preds = %541
%545 = getelementptr double, double* %6, i64 %542
%546 = getelementptr double, double* %8, i64 %542
%547 = getelementptr double, double* %10, i64 %542
%548 = icmp ugt double* %546, %6
%549 = icmp ugt double* %545, %8
%550 = and i1 %548, %549
%551 = icmp ugt double* %547, %6
%552 = icmp ugt double* %545, %10
%553 = and i1 %551, %552
%554 = or i1 %550, %553
%555 = icmp ugt double* %547, %8
%556 = icmp ugt double* %546, %10
%557 = and i1 %555, %556
%558 = or i1 %554, %557
br i1 %558, label %635, label %559
559: ; preds = %544
%560 = and i64 %542, 4294967292
%561 = add nsw i64 %560, -4
%562 = lshr exact i64 %561, 2
%563 = add nuw nsw i64 %562, 1
%564 = and i64 %563, 1
%565 = icmp eq i64 %561, 0
br i1 %565, label %611, label %566
566: ; preds = %559
%567 = and i64 %563, 9223372036854775806
br label %568
568: ; preds = %568, %566
%569 = phi i64 [ 0, %566 ], [ %608, %568 ]
%570 = phi i64 [ 0, %566 ], [ %609, %568 ]
%571 = getelementptr inbounds double, double* %8, i64 %569
%572 = bitcast double* %571 to <2 x double>*
%573 = load <2 x double>, <2 x double>* %572
%574 = getelementptr inbounds double, double* %571, i64 2
%575 = bitcast double* %574 to <2 x double>*
%576 = load <2 x double>, <2 x double>* %575
%577 = getelementptr inbounds double, double* %6, i64 %569
%578 = bitcast double* %577 to <2 x double>*
store <2 x double> %573, <2 x double>* %578
%579 = getelementptr inbounds double, double* %577, i64 2
%580 = bitcast double* %579 to <2 x double>*
store <2 x double> %576, <2 x double>* %580
%581 = getelementptr inbounds double, double* %10, i64 %569
%582 = bitcast double* %581 to <2 x double>*
%583 = load <2 x double>, <2 x double>* %582
%584 = getelementptr inbounds double, double* %581, i64 2
%585 = bitcast double* %584 to <2 x double>*
%586 = load <2 x double>, <2 x double>* %585
%587 = bitcast double* %571 to <2 x double>*
store <2 x double> %583, <2 x double>* %587
%588 = bitcast double* %574 to <2 x double>*
store <2 x double> %586, <2 x double>* %588
%589 = or i64 %569, 4
%590 = getelementptr inbounds double, double* %8, i64 %589
%591 = bitcast double* %590 to <2 x double>*
%592 = load <2 x double>, <2 x double>* %591
%593 = getelementptr inbounds double, double* %590, i64 2
%594 = bitcast double* %593 to <2 x double>*
%595 = load <2 x double>, <2 x double>* %594
%596 = getelementptr inbounds double, double* %6, i64 %589
%597 = bitcast double* %596 to <2 x double>*
store <2 x double> %592, <2 x double>* %597
%598 = getelementptr inbounds double, double* %596, i64 2
%599 = bitcast double* %598 to <2 x double>*
store <2 x double> %595, <2 x double>* %599
%600 = getelementptr inbounds double, double* %10, i64 %589
%601 = bitcast double* %600 to <2 x double>*
%602 = load <2 x double>, <2 x double>* %601
%603 = getelementptr inbounds double, double* %600, i64 2
%604 = bitcast double* %603 to <2 x double>*
%605 = load <2 x double>, <2 x double>* %604
%606 = bitcast double* %590 to <2 x double>*
store <2 x double> %602, <2 x double>* %606
%607 = bitcast double* %593 to <2 x double>*
store <2 x double> %605, <2 x double>* %607
%608 = add nuw i64 %569, 8
%609 = add i64 %570, 2
%610 = icmp eq i64 %609, %567
br i1 %610, label %611, label %568
611: ; preds = %568, %559
%612 = phi i64 [ 0, %559 ], [ %608, %568 ]
%613 = icmp eq i64 %564, 0
br i1 %613, label %633, label %614
614: ; preds = %611
%615 = getelementptr inbounds double, double* %8, i64 %612
%616 = bitcast double* %615 to <2 x double>*
%617 = load <2 x double>, <2 x double>* %616
%618 = getelementptr inbounds double, double* %615, i64 2
%619 = bitcast double* %618 to <2 x double>*
%620 = load <2 x double>, <2 x double>* %619
%621 = getelementptr inbounds double, double* %6, i64 %612
%622 = bitcast double* %621 to <2 x double>*
store <2 x double> %617, <2 x double>* %622
%623 = getelementptr inbounds double, double* %621, i64 2
%624 = bitcast double* %623 to <2 x double>*
store <2 x double> %620, <2 x double>* %624
%625 = getelementptr inbounds double, double* %10, i64 %612
%626 = bitcast double* %625 to <2 x double>*
%627 = load <2 x double>, <2 x double>* %626
%628 = getelementptr inbounds double, double* %625, i64 2
%629 = bitcast double* %628 to <2 x double>*
%630 = load <2 x double>, <2 x double>* %629
%631 = bitcast double* %615 to <2 x double>*
store <2 x double> %627, <2 x double>* %631
%632 = bitcast double* %618 to <2 x double>*
store <2 x double> %630, <2 x double>* %632
br label %633
633: ; preds = %611, %614
%634 = icmp eq i64 %560, %542
br i1 %634, label %666, label %635
635: ; preds = %544, %541, %633
%636 = phi i64 [ 0, %544 ], [ 0, %541 ], [ %560, %633 ]
%637 = xor i64 %636, -1
%638 = and i64 %542, 1
%639 = icmp eq i64 %638, 0
br i1 %639, label %647, label %640
640: ; preds = %635
%641 = getelementptr inbounds double, double* %8, i64 %636
%642 = load double, double* %641
%643 = getelementptr inbounds double, double* %6, i64 %636
store double %642, double* %643
%644 = getelementptr inbounds double, double* %10, i64 %636
%645 = load double, double* %644
store double %645, double* %641
%646 = or i64 %636, 1
br label %647
647: ; preds = %640, %635
%648 = phi i64 [ %636, %635 ], [ %646, %640 ]
%649 = sub nsw i64 0, %542
%650 = icmp eq i64 %637, %649
br i1 %650, label %666, label %651
651: ; preds = %647, %651
%652 = phi i64 [ %664, %651 ], [ %648, %647 ]
%653 = getelementptr inbounds double, double* %8, i64 %652
%654 = load double, double* %653
%655 = getelementptr inbounds double, double* %6, i64 %652
store double %654, double* %655
%656 = getelementptr inbounds double, double* %10, i64 %652
%657 = load double, double* %656
store double %657, double* %653
%658 = add nuw nsw i64 %652, 1
%659 = getelementptr inbounds double, double* %8, i64 %658
%660 = load double, double* %659
%661 = getelementptr inbounds double, double* %6, i64 %658
store double %660, double* %661
%662 = getelementptr inbounds double, double* %10, i64 %658
%663 = load double, double* %662
store double %663, double* %659
%664 = add nuw nsw i64 %652, 2
%665 = icmp eq i64 %664, %542
br i1 %665, label %666, label %651
666: ; preds = %647, %651, %633
%667 = load double, double* %7
br label %668
668: ; preds = %666, %537
%669 = phi double [ %667, %666 ], [ %539, %537 ]
%670 = fadd double %669, %4
br label %798
671: ; preds = %529
store double -1.000000e+100, double* %5
store double -1.000000e+100, double* %9
store double %0, double* %7
tail call void %3(double %0, double* %8)
%672 = icmp sgt i32 %2, 0
br i1 %672, label %673, label %903
673: ; preds = %671
%674 = zext i32 %2 to i64
%675 = icmp ult i32 %2, 4
br i1 %675, label %761, label %676
676: ; preds = %673
%677 = getelementptr double, double* %1, i64 %674
%678 = getelementptr double, double* %8, i64 %674
%679 = icmp ugt double* %678, %1
%680 = icmp ugt double* %677, %8
%681 = and i1 %679, %680
br i1 %681, label %761, label %682
682: ; preds = %676
%683 = and i64 %674, 4294967292
%684 = add nsw i64 %683, -4
%685 = lshr exact i64 %684, 2
%686 = add nuw nsw i64 %685, 1
%687 = and i64 %686, 3
%688 = icmp ult i64 %684, 12
br i1 %688, label %740, label %689
689: ; preds = %682
%690 = and i64 %686, 9223372036854775804
br label %691
691: ; preds = %691, %689
%692 = phi i64 [ 0, %689 ], [ %737, %691 ]
%693 = phi i64 [ 0, %689 ], [ %738, %691 ]
%694 = getelementptr inbounds double, double* %8, i64 %692
%695 = bitcast double* %694 to <2 x double>*
%696 = load <2 x double>, <2 x double>* %695
%697 = getelementptr inbounds double, double* %694, i64 2
%698 = bitcast double* %697 to <2 x double>*
%699 = load <2 x double>, <2 x double>* %698
%700 = getelementptr inbounds double, double* %1, i64 %692
%701 = bitcast double* %700 to <2 x double>*
store <2 x double> %696, <2 x double>* %701
%702 = getelementptr inbounds double, double* %700, i64 2
%703 = bitcast double* %702 to <2 x double>*
store <2 x double> %699, <2 x double>* %703
%704 = or i64 %692, 4
%705 = getelementptr inbounds double, double* %8, i64 %704
%706 = bitcast double* %705 to <2 x double>*
%707 = load <2 x double>, <2 x double>* %706
%708 = getelementptr inbounds double, double* %705, i64 2
%709 = bitcast double* %708 to <2 x double>*
%710 = load <2 x double>, <2 x double>* %709
%711 = getelementptr inbounds double, double* %1, i64 %704
%712 = bitcast double* %711 to <2 x double>*
store <2 x double> %707, <2 x double>* %712
%713 = getelementptr inbounds double, double* %711, i64 2
%714 = bitcast double* %713 to <2 x double>*
store <2 x double> %710, <2 x double>* %714
%715 = or i64 %692, 8
%716 = getelementptr inbounds double, double* %8, i64 %715
%717 = bitcast double* %716 to <2 x double>*
%718 = load <2 x double>, <2 x double>* %717
%719 = getelementptr inbounds double, double* %716, i64 2
%720 = bitcast double* %719 to <2 x double>*
%721 = load <2 x double>, <2 x double>* %720
%722 = getelementptr inbounds double, double* %1, i64 %715
%723 = bitcast double* %722 to <2 x double>*
store <2 x double> %718, <2 x double>* %723
%724 = getelementptr inbounds double, double* %722, i64 2
%725 = bitcast double* %724 to <2 x double>*
store <2 x double> %721, <2 x double>* %725
%726 = or i64 %692, 12
%727 = getelementptr inbounds double, double* %8, i64 %726
%728 = bitcast double* %727 to <2 x double>*
%729 = load <2 x double>, <2 x double>* %728
%730 = getelementptr inbounds double, double* %727, i64 2
%731 = bitcast double* %730 to <2 x double>*
%732 = load <2 x double>, <2 x double>* %731
%733 = getelementptr inbounds double, double* %1, i64 %726
%734 = bitcast double* %733 to <2 x double>*
store <2 x double> %729, <2 x double>* %734
%735 = getelementptr inbounds double, double* %733, i64 2
%736 = bitcast double* %735 to <2 x double>*
store <2 x double> %732, <2 x double>* %736
%737 = add nuw i64 %692, 16
%738 = add nuw i64 %693, 4
%739 = icmp eq i64 %738, %690
br i1 %739, label %740, label %691
740: ; preds = %691, %682
%741 = phi i64 [ 0, %682 ], [ %737, %691 ]
%742 = icmp eq i64 %687, 0
br i1 %742, label %759, label %743
743: ; preds = %740, %743
%744 = phi i64 [ %756, %743 ], [ %741, %740 ]
%745 = phi i64 [ %757, %743 ], [ 0, %740 ]
%746 = getelementptr inbounds double, double* %8, i64 %744
%747 = bitcast double* %746 to <2 x double>*
%748 = load <2 x double>, <2 x double>* %747
%749 = getelementptr inbounds double, double* %746, i64 2
%750 = bitcast double* %749 to <2 x double>*
%751 = load <2 x double>, <2 x double>* %750
%752 = getelementptr inbounds double, double* %1, i64 %744
%753 = bitcast double* %752 to <2 x double>*
store <2 x double> %748, <2 x double>* %753
%754 = getelementptr inbounds double, double* %752, i64 2
%755 = bitcast double* %754 to <2 x double>*
store <2 x double> %751, <2 x double>* %755
%756 = add nuw i64 %744, 4
%757 = add i64 %745, 1
%758 = icmp eq i64 %757, %687
br i1 %758, label %759, label %743
759: ; preds = %743, %740
%760 = icmp eq i64 %683, %674
br i1 %760, label %903, label %761
761: ; preds = %676, %673, %759
%762 = phi i64 [ 0, %676 ], [ 0, %673 ], [ %683, %759 ]
%763 = xor i64 %762, -1
%764 = add nsw i64 %763, %674
%765 = and i64 %674, 3
%766 = icmp eq i64 %765, 0
br i1 %766, label %776, label %767
767: ; preds = %761, %767
%768 = phi i64 [ %773, %767 ], [ %762, %761 ]
%769 = phi i64 [ %774, %767 ], [ 0, %761 ]
%770 = getelementptr inbounds double, double* %8, i64 %768
%771 = load double, double* %770
%772 = getelementptr inbounds double, double* %1, i64 %768
store double %771, double* %772
%773 = add nuw nsw i64 %768, 1
%774 = add i64 %769, 1
%775 = icmp eq i64 %774, %765
br i1 %775, label %776, label %767
776: ; preds = %767, %761
%777 = phi i64 [ %762, %761 ], [ %773, %767 ]
%778 = icmp ult i64 %764, 3
br i1 %778, label %903, label %779
779: ; preds = %776, %779
%780 = phi i64 [ %796, %779 ], [ %777, %776 ]
%781 = getelementptr inbounds double, double* %8, i64 %780
%782 = load double, double* %781
%783 = getelementptr inbounds double, double* %1, i64 %780
store double %782, double* %783
%784 = add nuw nsw i64 %780, 1
%785 = getelementptr inbounds double, double* %8, i64 %784
%786 = load double, double* %785
%787 = getelementptr inbounds double, double* %1, i64 %784
store double %786, double* %787
%788 = add nuw nsw i64 %780, 2
%789 = getelementptr inbounds double, double* %8, i64 %788
%790 = load double, double* %789
%791 = getelementptr inbounds double, double* %1, i64 %788
store double %790, double* %791
%792 = add nuw nsw i64 %780, 3
%793 = getelementptr inbounds double, double* %8, i64 %792
%794 = load double, double* %793
%795 = getelementptr inbounds double, double* %1, i64 %792
store double %794, double* %795
%796 = add nuw nsw i64 %780, 4
%797 = icmp eq i64 %796, %674
br i1 %797, label %903, label %779
798: ; preds = %526, %668
%799 = phi double [ %670, %668 ], [ %524, %526 ]
store double %799, double* %9
tail call void %3(double %799, double* %10)
br label %800
800: ; preds = %798, %526
%801 = load double, double* %9
%802 = fsub double %801, %0
%803 = load double, double* %7
%804 = fsub double %0, %803
%805 = fdiv double 1.000000e+00, %4
%806 = icmp sgt i32 %2, 0
br i1 %806, label %807, label %903
807: ; preds = %800
%808 = zext i32 %2 to i64
%809 = icmp ult i32 %2, 4
br i1 %809, label %863, label %810
810: ; preds = %807
%811 = getelementptr double, double* %1, i64 %808
%812 = getelementptr double, double* %8, i64 %808
%813 = getelementptr double, double* %10, i64 %808
%814 = icmp ugt double* %812, %1
%815 = icmp ugt double* %811, %8
%816 = and i1 %814, %815
%817 = icmp ugt double* %813, %1
%818 = icmp ugt double* %811, %10
%819 = and i1 %817, %818
%820 = or i1 %816, %819
br i1 %820, label %863, label %821
821: ; preds = %810
%822 = and i64 %808, 4294967292
%823 = insertelement <2 x double> poison, double %804, i64 0
%824 = shufflevector <2 x double> %823, <2 x double> poison, <2 x i32> zeroinitializer
%825 = insertelement <2 x double> poison, double %804, i64 0
%826 = shufflevector <2 x double> %825, <2 x double> poison, <2 x i32> zeroinitializer
%827 = insertelement <2 x double> poison, double %802, i64 0
%828 = shufflevector <2 x double> %827, <2 x double> poison, <2 x i32> zeroinitializer
%829 = insertelement <2 x double> poison, double %802, i64 0
%830 = shufflevector <2 x double> %829, <2 x double> poison, <2 x i32> zeroinitializer
%831 = insertelement <2 x double> poison, double %805, i64 0
%832 = shufflevector <2 x double> %831, <2 x double> poison, <2 x i32> zeroinitializer
%833 = insertelement <2 x double> poison, double %805, i64 0
%834 = shufflevector <2 x double> %833, <2 x double> poison, <2 x i32> zeroinitializer
br label %835
835: ; preds = %835, %821
%836 = phi i64 [ 0, %821 ], [ %859, %835 ]
%837 = getelementptr inbounds double, double* %8, i64 %836
%838 = bitcast double* %837 to <2 x double>*
%839 = load <2 x double>, <2 x double>* %838
%840 = getelementptr inbounds double, double* %837, i64 2
%841 = bitcast double* %840 to <2 x double>*
%842 = load <2 x double>, <2 x double>* %841
%843 = getelementptr inbounds double, double* %10, i64 %836
%844 = bitcast double* %843 to <2 x double>*
%845 = load <2 x double>, <2 x double>* %844
%846 = getelementptr inbounds double, double* %843, i64 2
%847 = bitcast double* %846 to <2 x double>*
%848 = load <2 x double>, <2 x double>* %847
%849 = fmul <2 x double> %824, %845
%850 = fmul <2 x double> %826, %848
%851 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %839, <2 x double> %828, <2 x double> %849)
%852 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %842, <2 x double> %830, <2 x double> %850)
%853 = fmul <2 x double> %832, %851
%854 = fmul <2 x double> %834, %852
%855 = getelementptr inbounds double, double* %1, i64 %836
%856 = bitcast double* %855 to <2 x double>*
store <2 x double> %853, <2 x double>* %856
%857 = getelementptr inbounds double, double* %855, i64 2
%858 = bitcast double* %857 to <2 x double>*
store <2 x double> %854, <2 x double>* %858
%859 = add nuw i64 %836, 4
%860 = icmp eq i64 %859, %822
br i1 %860, label %861, label %835
861: ; preds = %835
%862 = icmp eq i64 %822, %808
br i1 %862, label %903, label %863
863: ; preds = %810, %807, %861
%864 = phi i64 [ 0, %810 ], [ 0, %807 ], [ %822, %861 ]
%865 = xor i64 %864, -1
%866 = and i64 %808, 1
%867 = icmp eq i64 %866, 0
br i1 %867, label %878, label %868
868: ; preds = %863
%869 = getelementptr inbounds double, double* %8, i64 %864
%870 = load double, double* %869
%871 = getelementptr inbounds double, double* %10, i64 %864
%872 = load double, double* %871
%873 = fmul double %804, %872
%874 = tail call double @llvm.fmuladd.f64(double %870, double %802, double %873)
%875 = fmul double %805, %874
%876 = getelementptr inbounds double, double* %1, i64 %864
store double %875, double* %876
%877 = or i64 %864, 1
br label %878
878: ; preds = %868, %863
%879 = phi i64 [ %864, %863 ], [ %877, %868 ]
%880 = sub nsw i64 0, %808
%881 = icmp eq i64 %865, %880
br i1 %881, label %903, label %882
882: ; preds = %878, %882
%883 = phi i64 [ %901, %882 ], [ %879, %878 ]
%884 = getelementptr inbounds double, double* %8, i64 %883
%885 = load double, double* %884
%886 = getelementptr inbounds double, double* %10, i64 %883
%887 = load double, double* %886
%888 = fmul double %804, %887
%889 = tail call double @llvm.fmuladd.f64(double %885, double %802, double %888)
%890 = fmul double %805, %889
%891 = getelementptr inbounds double, double* %1, i64 %883
store double %890, double* %891
%892 = add nuw nsw i64 %883, 1
%893 = getelementptr inbounds double, double* %8, i64 %892
%894 = load double, double* %893
%895 = getelementptr inbounds double, double* %10, i64 %892
%896 = load double, double* %895
%897 = fmul double %804, %896
%898 = tail call double @llvm.fmuladd.f64(double %894, double %802, double %897)
%899 = fmul double %805, %898
%900 = getelementptr inbounds double, double* %1, i64 %892
store double %899, double* %900
%901 = add nuw nsw i64 %883, 2
%902 = icmp eq i64 %901, %808
br i1 %902, label %903, label %882
903: ; preds = %498, %502, %396, %399, %878, %882, %776, %779, %119, %122, %481, %379, %861, %759, %102, %420, %291, %800, %671, %14
ret void
}