void CalcInterpolatedElements(const double t, double elem[], const int dim,
                              void (*calc_func)(const double t, double elem[],
                                                void *user),
                              const double delta_t, double *t0, double e0[],
                              double *t1, double e1[], double *t2, double e2[],
                              void *user) {
  int i;
  if (*t1 < -1e99) {
    *t0 = -1e100;
    *t2 = -1e100;
    *t1 = t;
    (*calc_func)(*t1, e1, user);
    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, user);
      }
    } else if (*t1 - 2.0 * delta_t <= t) {
      if (*t0 < -1e99) {
        *t0 = *t1 - delta_t;
        (*calc_func)(*t0, e0, user);
      }
      *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, user);
    } else {
      *t0 = -1e100;
      *t2 = -1e100;
      *t1 = t;
      (*calc_func)(*t1, e1, user);
      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, user);
      }
    } else if (*t1 + 2.0 * delta_t >= t) {
      if (*t2 < -1e99) {
        *t2 = *t1 + delta_t;
        (*calc_func)(*t2, e2, user);
      }
      *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, user);
    } else {
      *t0 = -1e100;
      *t2 = -1e100;
      *t1 = t;
      (*calc_func)(*t1, e1, user);
      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    0x28(%rbp),%rax
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  0xeb8(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    11d5 <CalcInterpolatedElements+0xd5>
mov    -0x30(%rbp),%rax
movsd  0xeaa(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  0xe9a(%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
mov    0x28(%rbp),%rsi
call   *%rax
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d0 <CalcInterpolatedElements+0xd0>
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    119c <CalcInterpolatedElements+0x9c>
jmp    1708 <CalcInterpolatedElements+0x608>
movsd  -0x8(%rbp),%xmm1
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     147e <CalcInterpolatedElements+0x37e>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
subsd  -0x28(%rbp),%xmm1
movsd  -0x8(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     124e <CalcInterpolatedElements+0x14e>
mov    -0x30(%rbp),%rax
movsd  0xdec(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    1249 <CalcInterpolatedElements+0x149>
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
mov    0x28(%rbp),%rsi
call   *%rax
jmp    13e0 <CalcInterpolatedElements+0x2e0>
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     1358 <CalcInterpolatedElements+0x258>
mov    -0x30(%rbp),%rax
movsd  0xd82(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    12b3 <CalcInterpolatedElements+0x1b3>
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
mov    0x28(%rbp),%rsi
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    1328 <CalcInterpolatedElements+0x228>
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    12da <CalcInterpolatedElements+0x1da>
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
mov    0x28(%rbp),%rsi
call   *%rax
jmp    13db <CalcInterpolatedElements+0x2db>
mov    -0x30(%rbp),%rax
movsd  0xca4(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  0xc94(%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
mov    0x28(%rbp),%rsi
call   *%rax
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13d6 <CalcInterpolatedElements+0x2d6>
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    13a2 <CalcInterpolatedElements+0x2a2>
jmp    1708 <CalcInterpolatedElements+0x608>
jmp    13e0 <CalcInterpolatedElements+0x2e0>
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  0xc04(%rip),%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1479 <CalcInterpolatedElements+0x379>
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    141d <CalcInterpolatedElements+0x31d>
jmp    1708 <CalcInterpolatedElements+0x608>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x28(%rbp),%xmm0
ucomisd -0x8(%rbp),%xmm0
jb     14dc <CalcInterpolatedElements+0x3dc>
mov    0x18(%rbp),%rax
movsd  0xb5e(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    14d7 <CalcInterpolatedElements+0x3d7>
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
mov    0x28(%rbp),%rsi
call   *%rax
jmp    166a <CalcInterpolatedElements+0x56a>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x28(%rbp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd -0x8(%rbp),%xmm0
jb     15e2 <CalcInterpolatedElements+0x4e2>
mov    0x18(%rbp),%rax
movsd  0xaf8(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    153d <CalcInterpolatedElements+0x43d>
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
mov    0x28(%rbp),%rsi
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    15b2 <CalcInterpolatedElements+0x4b2>
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    1564 <CalcInterpolatedElements+0x464>
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
mov    0x28(%rbp),%rsi
call   *%rax
jmp    1665 <CalcInterpolatedElements+0x565>
mov    -0x30(%rbp),%rax
movsd  0xa1a(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  0xa0a(%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
mov    0x28(%rbp),%rsi
call   *%rax
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1660 <CalcInterpolatedElements+0x560>
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    162c <CalcInterpolatedElements+0x52c>
jmp    1708 <CalcInterpolatedElements+0x608>
jmp    166a <CalcInterpolatedElements+0x56a>
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  0x97a(%rip),%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1703 <CalcInterpolatedElements+0x603>
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    16a7 <CalcInterpolatedElements+0x5a7>
jmp    1708 <CalcInterpolatedElements+0x608>
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    0x88(%rsp),%rsi
mov    0x78(%rsp),%rbp
mov    0x70(%rsp),%r14
movsd  (%r9),%xmm1
movsd  0xec4(%rip),%xmm2
ucomisd %xmm1,%xmm2
jbe    1210 <CalcInterpolatedElements+0x110>
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    1f37 <CalcInterpolatedElements+0xe37>
mov    %r13d,%eax
cmp    $0x4,%r13d
jb     1192 <CalcInterpolatedElements+0x92>
lea    (%r14,%rax,8),%rcx
cmp    %rbx,%rcx
jbe    1431 <CalcInterpolatedElements+0x331>
lea    (%rbx,%rax,8),%rcx
cmp    %r14,%rcx
jbe    1431 <CalcInterpolatedElements+0x331>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     11c5 <CalcInterpolatedElements+0xc5>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11b0 <CalcInterpolatedElements+0xb0>
cmp    $0x3,%rdx
jb     1f37 <CalcInterpolatedElements+0xe37>
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    11d0 <CalcInterpolatedElements+0xd0>
jmp    1f37 <CalcInterpolatedElements+0xe37>
mov    %r8,%r15
mov    0x80(%rsp),%r12
movapd %xmm1,%xmm0
ucomisd %xmm9,%xmm1
jae    1310 <CalcInterpolatedElements+0x210>
addsd  %xmm5,%xmm0
ucomisd %xmm9,%xmm0
jae    1400 <CalcInterpolatedElements+0x300>
movapd %xmm5,%xmm3
addsd  %xmm5,%xmm3
addsd  %xmm1,%xmm3
ucomisd %xmm9,%xmm3
jae    145b <CalcInterpolatedElements+0x35b>
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    1f37 <CalcInterpolatedElements+0xe37>
mov    %r13d,%eax
cmp    $0x4,%r13d
jb     129c <CalcInterpolatedElements+0x19c>
lea    (%r14,%rax,8),%rcx
cmp    %rbx,%rcx
jbe    1842 <CalcInterpolatedElements+0x742>
lea    (%rbx,%rax,8),%rcx
cmp    %r14,%rcx
jbe    1842 <CalcInterpolatedElements+0x742>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     12c5 <CalcInterpolatedElements+0x1c5>
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    12b0 <CalcInterpolatedElements+0x1b0>
cmp    $0x3,%rdx
jb     1f37 <CalcInterpolatedElements+0xe37>
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    12d0 <CalcInterpolatedElements+0x1d0>
jmp    1f37 <CalcInterpolatedElements+0xe37>
subsd  %xmm5,%xmm0
ucomisd %xmm0,%xmm9
jae    1419 <CalcInterpolatedElements+0x319>
movapd %xmm5,%xmm3
addsd  %xmm5,%xmm3
movapd %xmm1,%xmm4
subsd  %xmm3,%xmm4
ucomisd %xmm4,%xmm9
jae    14e3 <CalcInterpolatedElements+0x3e3>
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    1f37 <CalcInterpolatedElements+0xe37>
mov    %r13d,%eax
cmp    $0x4,%r13d
jb     1386 <CalcInterpolatedElements+0x286>
lea    (%r14,%rax,8),%rcx
cmp    %rbx,%rcx
jbe    1868 <CalcInterpolatedElements+0x768>
lea    (%rbx,%rax,8),%rcx
cmp    %r14,%rcx
jbe    1868 <CalcInterpolatedElements+0x768>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     13b5 <CalcInterpolatedElements+0x2b5>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    13a0 <CalcInterpolatedElements+0x2a0>
cmp    $0x3,%rdx
jb     1f37 <CalcInterpolatedElements+0xe37>
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    13c0 <CalcInterpolatedElements+0x2c0>
jmp    1f37 <CalcInterpolatedElements+0xe37>
ucomisd 0x0(%rbp),%xmm2
ja     1b06 <CalcInterpolatedElements+0xa06>
test   %r13d,%r13d
jg     1b3f <CalcInterpolatedElements+0xa3f>
jmp    1f37 <CalcInterpolatedElements+0xe37>
ucomisd (%rcx),%xmm2
ja     1d66 <CalcInterpolatedElements+0xc66>
test   %r13d,%r13d
jg     1da4 <CalcInterpolatedElements+0xca4>
jmp    1f37 <CalcInterpolatedElements+0xe37>
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    1569 <CalcInterpolatedElements+0x469>
xor    %edi,%edi
jmp    15d4 <CalcInterpolatedElements+0x4d4>
ucomisd 0x0(%rbp),%xmm2
jbe    14b8 <CalcInterpolatedElements+0x3b8>
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    0x88(%rsp),%rsi
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    1b02 <CalcInterpolatedElements+0xa02>
mov    %r13d,%r8d
cmp    $0x4,%r13d
jae    161d <CalcInterpolatedElements+0x51d>
xor    %ecx,%ecx
jmp    1a93 <CalcInterpolatedElements+0x993>
ucomisd (%rcx),%xmm2
jbe    153e <CalcInterpolatedElements+0x43e>
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    0x88(%rsp),%rsi
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    1d62 <CalcInterpolatedElements+0xc62>
mov    %r13d,%r8d
cmp    $0x4,%r13d
jae    172b <CalcInterpolatedElements+0x62b>
xor    %ebp,%ebp
jmp    1cf3 <CalcInterpolatedElements+0xbf3>
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    1570 <CalcInterpolatedElements+0x470>
test   %rdx,%rdx
je     160f <CalcInterpolatedElements+0x50f>
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    15f0 <CalcInterpolatedElements+0x4f0>
cmp    %rax,%rcx
je     1f37 <CalcInterpolatedElements+0xe37>
jmp    1194 <CalcInterpolatedElements+0x94>
mov    %rdx,0x8(%rsp)
mov    %r9,%rbp
lea    (%r14,%r8,8),%rcx
cmp    %r15,%rcx
seta   %r9b
lea    (%r15,%r8,8),%rsi
cmp    %r14,%rsi
seta   %r10b
lea    (%r12,%r8,8),%rdi
cmp    %r15,%rdi
seta   %dl
cmp    %r12,%rsi
seta   %r11b
cmp    %r14,%rdi
seta   %sil
cmp    %r12,%rcx
seta   %al
xor    %ecx,%ecx
test   %r10b,%r9b
jne    1a7e <CalcInterpolatedElements+0x97e>
and    %r11b,%dl
mov    %rbp,%r9
jne    1a81 <CalcInterpolatedElements+0x981>
and    %al,%sil
mov    0x8(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x78(%rsp),%rbp
jne    1a93 <CalcInterpolatedElements+0x993>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rdi,%rdi
je     19f6 <CalcInterpolatedElements+0x8f6>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
and    %r10,%rdi
xor    %eax,%eax
movups (%r14,%rax,8),%xmm0
movups 0x10(%r14,%rax,8),%xmm1
movups %xmm0,(%r15,%rax,8)
movups %xmm1,0x10(%r15,%rax,8)
movups (%r12,%rax,8),%xmm0
movups 0x10(%r12,%rax,8),%xmm1
movups %xmm0,(%r14,%rax,8)
movups %xmm1,0x10(%r14,%rax,8)
movups 0x20(%r14,%rax,8),%xmm0
movups 0x30(%r14,%rax,8),%xmm1
movups %xmm0,0x20(%r15,%rax,8)
movups %xmm1,0x30(%r15,%rax,8)
movupd 0x20(%r12,%rax,8),%xmm0
movupd 0x30(%r12,%rax,8),%xmm1
movupd %xmm0,0x20(%r14,%rax,8)
movupd %xmm1,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    16bc <CalcInterpolatedElements+0x5bc>
jmp    19f8 <CalcInterpolatedElements+0x8f8>
mov    %rcx,0x30(%rsp)
mov    %rdx,0x8(%rsp)
mov    %r9,0x18(%rsp)
lea    (%r14,%r8,8),%rcx
cmp    %r12,%rcx
seta   %r9b
lea    (%r12,%r8,8),%rsi
cmp    %r14,%rsi
seta   %r10b
lea    (%r15,%r8,8),%rdi
cmp    %r12,%rdi
seta   %dl
cmp    %r15,%rsi
seta   %r11b
cmp    %r14,%rdi
seta   %sil
cmp    %r15,%rcx
seta   %al
xor    %ebp,%ebp
test   %r10b,%r9b
jne    1cdc <CalcInterpolatedElements+0xbdc>
and    %r11b,%dl
mov    0x18(%rsp),%r9
jne    1ce1 <CalcInterpolatedElements+0xbe1>
and    %al,%sil
mov    0x8(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x30(%rsp),%rcx
jne    1cf3 <CalcInterpolatedElements+0xbf3>
mov    %r8d,%ebp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%rdi
mov    %rdi,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rdi,%rdi
je     1a38 <CalcInterpolatedElements+0x938>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
and    %r10,%rdi
xor    %eax,%eax
movups (%r14,%rax,8),%xmm0
movups 0x10(%r14,%rax,8),%xmm1
movups %xmm0,(%r12,%rax,8)
movups %xmm1,0x10(%r12,%rax,8)
movups (%r15,%rax,8),%xmm0
movups 0x10(%r15,%rax,8),%xmm1
movups %xmm0,(%r14,%rax,8)
movups %xmm1,0x10(%r14,%rax,8)
movups 0x20(%r14,%rax,8),%xmm0
movups 0x30(%r14,%rax,8),%xmm1
movups %xmm0,0x20(%r12,%rax,8)
movups %xmm1,0x30(%r12,%rax,8)
movupd 0x20(%r15,%rax,8),%xmm0
movupd 0x30(%r15,%rax,8),%xmm1
movupd %xmm0,0x20(%r14,%rax,8)
movupd %xmm1,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    17d3 <CalcInterpolatedElements+0x6d3>
jmp    1a3a <CalcInterpolatedElements+0x93a>
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    1892 <CalcInterpolatedElements+0x792>
xor    %edi,%edi
jmp    18fc <CalcInterpolatedElements+0x7fc>
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    1944 <CalcInterpolatedElements+0x844>
xor    %edi,%edi
jmp    19ae <CalcInterpolatedElements+0x8ae>
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    1898 <CalcInterpolatedElements+0x798>
test   %rdx,%rdx
je     1936 <CalcInterpolatedElements+0x836>
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    1917 <CalcInterpolatedElements+0x817>
cmp    %rax,%rcx
je     1f37 <CalcInterpolatedElements+0xe37>
jmp    129e <CalcInterpolatedElements+0x19e>
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    194a <CalcInterpolatedElements+0x84a>
test   %rdx,%rdx
je     19e8 <CalcInterpolatedElements+0x8e8>
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    19c9 <CalcInterpolatedElements+0x8c9>
cmp    %rax,%rcx
je     1f37 <CalcInterpolatedElements+0xe37>
jmp    1388 <CalcInterpolatedElements+0x288>
xor    %eax,%eax
test   $0x1,%r10b
je     1a2e <CalcInterpolatedElements+0x92e>
movups (%r14,%rax,8),%xmm0
movups 0x10(%r14,%rax,8),%xmm1
movups %xmm0,(%r15,%rax,8)
movups %xmm1,0x10(%r15,%rax,8)
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
cmp    %r8,%rcx
jne    1a93 <CalcInterpolatedElements+0x993>
jmp    1afd <CalcInterpolatedElements+0x9fd>
xor    %eax,%eax
test   $0x1,%r10b
je     1a70 <CalcInterpolatedElements+0x970>
movups (%r14,%rax,8),%xmm0
movups 0x10(%r14,%rax,8),%xmm1
movups %xmm0,(%r12,%rax,8)
movups %xmm1,0x10(%r12,%rax,8)
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
cmp    %r8,%rbp
jne    1cf3 <CalcInterpolatedElements+0xbf3>
jmp    1d5d <CalcInterpolatedElements+0xc5d>
mov    %rbp,%r9
mov    0x8(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x78(%rsp),%rbp
mov    %rcx,%rdi
not    %rdi
test   $0x1,%r8b
je     1abb <CalcInterpolatedElements+0x9bb>
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
or     $0x1,%rcx
add    %r8,%rdi
je     1afd <CalcInterpolatedElements+0x9fd>
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,%r8
jne    1ac0 <CalcInterpolatedElements+0x9c0>
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    1f37 <CalcInterpolatedElements+0xe37>
movsd  0x0(%rbp),%xmm8
subsd  %xmm9,%xmm8
subsd  (%r9),%xmm9
movsd  0x4b1(%rip),%xmm1
divsd  %xmm5,%xmm1
mov    %r13d,%eax
cmp    $0x4,%r13d
jae    1c07 <CalcInterpolatedElements+0xb07>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     1b9b <CalcInterpolatedElements+0xa9b>
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     1f37 <CalcInterpolatedElements+0xe37>
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    1bb0 <CalcInterpolatedElements+0xab0>
jmp    1f37 <CalcInterpolatedElements+0xe37>
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    1b6a <CalcInterpolatedElements+0xa6a>
and    %sil,%dl
jne    1b6a <CalcInterpolatedElements+0xa6a>
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    1c80 <CalcInterpolatedElements+0xb80>
cmp    %rax,%rcx
jne    1b6a <CalcInterpolatedElements+0xa6a>
jmp    1f37 <CalcInterpolatedElements+0xe37>
mov    0x18(%rsp),%r9
mov    0x8(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x30(%rsp),%rcx
mov    %rbp,%rdi
not    %rdi
test   $0x1,%r8b
je     1d1b <CalcInterpolatedElements+0xc1b>
movsd  (%r14,%rbp,8),%xmm0
movsd  %xmm0,(%r12,%rbp,8)
movsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r14,%rbp,8)
or     $0x1,%rbp
add    %r8,%rdi
je     1d5d <CalcInterpolatedElements+0xc5d>
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,%r8
jne    1d20 <CalcInterpolatedElements+0xc20>
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    1f37 <CalcInterpolatedElements+0xe37>
movsd  (%r9),%xmm8
subsd  %xmm9,%xmm8
subsd  (%rcx),%xmm9
movsd  0x24d(%rip),%xmm1
divsd  %xmm5,%xmm1
mov    %r13d,%eax
cmp    $0x4,%r13d
jae    1e67 <CalcInterpolatedElements+0xd67>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     1dff <CalcInterpolatedElements+0xcff>
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     1f37 <CalcInterpolatedElements+0xe37>
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    1e10 <CalcInterpolatedElements+0xd10>
jmp    1f37 <CalcInterpolatedElements+0xe37>
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    1dce <CalcInterpolatedElements+0xcce>
and    %sil,%dl
jne    1dce <CalcInterpolatedElements+0xcce>
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    1ee0 <CalcInterpolatedElements+0xde0>
cmp    %rax,%rcx
jne    1dce <CalcInterpolatedElements+0xcce>
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*, i8*)* %3, double %4, double* %5, double* %6, double* %7, double* %8, double* %9, double* %10, i8* %11) {
%13 = alloca double
%14 = alloca double*
%15 = alloca i32
%16 = alloca void (double, double*, i8*)*
%17 = alloca double
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca i8*
%25 = alloca i32
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
store double %0, double* %13
store double* %1, double** %14
store i32 %2, i32* %15
store void (double, double*, i8*)* %3, void (double, double*, i8*)** %16
store double %4, double* %17
store double* %5, double** %18
store double* %6, double** %19
store double* %7, double** %20
store double* %8, double** %21
store double* %9, double** %22
store double* %10, double** %23
store i8* %11, i8** %24
%32 = load double*, double** %20
%33 = load double, double* %32
%34 = fcmp olt double %33, 0xD47D42AEA2879F2E
br i1 %34, label %35, label %63
35: ; preds = %12
%36 = load double*, double** %18
store double -1.000000e+100, double* %36
%37 = load double*, double** %22
store double -1.000000e+100, double* %37
%38 = load double, double* %13
%39 = load double*, double** %20
store double %38, double* %39
%40 = load void (double, double*, i8*)*, void (double, double*, i8*)** %16
%41 = load double*, double** %20
%42 = load double, double* %41
%43 = load double*, double** %21
%44 = load i8*, i8** %24
store i32 0, i32* %25
br label %45
45: ; preds = %59, %35
%46 = load i32, i32* %25
%47 = load i32, i32* %15
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %62
49: ; preds = %45
%50 = load double*, double** %21
%51 = load i32, i32* %25
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %50, i64 %52
%54 = load double, double* %53
%55 = load double*, double** %14
%56 = load i32, i32* %25
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds double, double* %55, i64 %57
store double %54, double* %58
br label %59
59: ; preds = %49
%60 = load i32, i32* %25
%61 = add nsw i32 %60, 1
store i32 %61, i32* %25
br label %45
62: ; preds = %45
br label %384
63: ; preds = %12
%64 = load double, double* %13
%65 = load double*, double** %20
%66 = load double, double* %65
%67 = fcmp ole double %64, %66
br i1 %67, label %68, label %226
68: ; preds = %63
%69 = load double*, double** %20
%70 = load double, double* %69
%71 = load double, double* %17
%72 = fsub double %70, %71
%73 = load double, double* %13
%74 = fcmp ole double %72, %73
br i1 %74, label %75, label %91
75: ; preds = %68
%76 = load double*, double** %18
%77 = load double, double* %76
%78 = fcmp olt double %77, 0xD47D42AEA2879F2E
br i1 %78, label %79, label %90
79: ; preds = %75
%80 = load double*, double** %20
%81 = load double, double* %80
%82 = load double, double* %17
%83 = fsub double %81, %82
%84 = load double*, double** %18
store double %83, double* %84
%85 = load void (double, double*, i8*)*, void (double, double*, i8*)** %16
%86 = load double*, double** %18
%87 = load double, double* %86
%88 = load double*, double** %19
%89 = load i8*, i8** %24
br label %90
90: ; preds = %79, %75
br label %186
91: ; preds = %68
%92 = load double*, double** %20
%93 = load double, double* %92
%94 = load double, double* %17
%95 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %94, double %93)
%96 = load double, double* %13
%97 = fcmp ole double %95, %96
br i1 %97, label %98, label %157
98: ; preds = %91
%99 = load double*, double** %18
%100 = load double, double* %99
%101 = fcmp olt double %100, 0xD47D42AEA2879F2E
br i1 %101, label %102, label %113
102: ; preds = %98
%103 = load double*, double** %20
%104 = load double, double* %103
%105 = load double, double* %17
%106 = fsub double %104, %105
%107 = load double*, double** %18
store double %106, double* %107
%108 = load void (double, double*, i8*)*, void (double, double*, i8*)** %16
%109 = load double*, double** %18
%110 = load double, double* %109
%111 = load double*, double** %19
%112 = load i8*, i8** %24
br label %113
113: ; preds = %102, %98
%114 = load double*, double** %20
%115 = load double, double* %114
%116 = load double*, double** %22
store double %115, double* %116
%117 = load double*, double** %18
%118 = load double, double* %117
%119 = load double*, double** %20
store double %118, double* %119
store i32 0, i32* %25
br label %120
120: ; preds = %143, %113
%121 = load i32, i32* %25
%122 = load i32, i32* %15
%123 = icmp slt i32 %121, %122
br i1 %123, label %124, label %146
124: ; preds = %120
%125 = load double*, double** %21
%126 = load i32, i32* %25
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
%129 = load double, double* %128
%130 = load double*, double** %23
%131 = load i32, i32* %25
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double, double* %130, i64 %132
store double %129, double* %133
%134 = load double*, double** %19
%135 = load i32, i32* %25
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %134, i64 %136
%138 = load double, double* %137
%139 = load double*, double** %21
%140 = load i32, i32* %25
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds double, double* %139, i64 %141
store double %138, double* %142
br label %143
143: ; preds = %124
%144 = load i32, i32* %25
%145 = add nsw i32 %144, 1
store i32 %145, i32* %25
br label %120
146: ; preds = %120
%147 = load double*, double** %20
%148 = load double, double* %147
%149 = load double, double* %17
%150 = fsub double %148, %149
%151 = load double*, double** %18
store double %150, double* %151
%152 = load void (double, double*, i8*)*, void (double, double*, i8*)** %16
%153 = load double*, double** %18
%154 = load double, double* %153
%155 = load double*, double** %19
%156 = load i8*, i8** %24
br label %185
157: ; preds = %91
%158 = load double*, double** %18
store double -1.000000e+100, double* %158
%159 = load double*, double** %22
store double -1.000000e+100, double* %159
%160 = load double, double* %13
%161 = load double*, double** %20
store double %160, double* %161
%162 = load void (double, double*, i8*)*, void (double, double*, i8*)** %16
%163 = load double*, double** %20
%164 = load double, double* %163
%165 = load double*, double** %21
%166 = load i8*, i8** %24
store i32 0, i32* %25
br label %167
167: ; preds = %181, %157
%168 = load i32, i32* %25
%169 = load i32, i32* %15
%170 = icmp slt i32 %168, %169
br i1 %170, label %171, label %184
171: ; preds = %167
%172 = load double*, double** %21
%173 = load i32, i32* %25
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %172, i64 %174
%176 = load double, double* %175
%177 = load double*, double** %14
%178 = load i32, i32* %25
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
store double %176, double* %180
br label %181
181: ; preds = %171
%182 = load i32, i32* %25
%183 = add nsw i32 %182, 1
store i32 %183, i32* %25
br label %167
184: ; preds = %167
br label %384
185: ; preds = %146
br label %186
186: ; preds = %185, %90
%187 = load double*, double** %20
%188 = load double, double* %187
%189 = load double, double* %13
%190 = fsub double %188, %189
store double %190, double* %26
%191 = load double, double* %13
%192 = load double*, double** %18
%193 = load double, double* %192
%194 = fsub double %191, %193
store double %194, double* %27
%195 = load double, double* %17
%196 = fdiv double 1.000000e+00, %195
store double %196, double* %28
store i32 0, i32* %25
br label %197
197: ; preds = %222, %186
%198 = load i32, i32* %25
%199 = load i32, i32* %15
%200 = icmp slt i32 %198, %199
br i1 %200, label %201, label %225
201: ; preds = %197
%202 = load double, double* %28
%203 = load double*, double** %19
%204 = load i32, i32* %25
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds double, double* %203, i64 %205
%207 = load double, double* %206
%208 = load double, double* %26
%209 = load double*, double** %21
%210 = load i32, i32* %25
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %209, i64 %211
%213 = load double, double* %212
%214 = load double, double* %27
%215 = fmul double %213, %214
%216 = call double @llvm.fmuladd.f64(double %207, double %208, double %215)
%217 = fmul double %202, %216
%218 = load double*, double** %14
%219 = load i32, i32* %25
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %218, i64 %220
store double %217, double* %221
br label %222
222: ; preds = %201
%223 = load i32, i32* %25
%224 = add nsw i32 %223, 1
store i32 %224, i32* %25
br label %197
225: ; preds = %197
br label %384
226: ; preds = %63
%227 = load double*, double** %20
%228 = load double, double* %227
%229 = load double, double* %17
%230 = fadd double %228, %229
%231 = load double, double* %13
%232 = fcmp oge double %230, %231
br i1 %232, label %233, label %249
233: ; preds = %226
%234 = load double*, double** %22
%235 = load double, double* %234
%236 = fcmp olt double %235, 0xD47D42AEA2879F2E
br i1 %236, label %237, label %248
237: ; preds = %233
%238 = load double*, double** %20
%239 = load double, double* %238
%240 = load double, double* %17
%241 = fadd double %239, %240
%242 = load double*, double** %22
store double %241, double* %242
%243 = load void (double, double*, i8*)*, void (double, double*, i8*)** %16
%244 = load double*, double** %22
%245 = load double, double* %244
%246 = load double*, double** %23
%247 = load i8*, i8** %24
br label %248
248: ; preds = %237, %233
br label %344
249: ; preds = %226
%250 = load double*, double** %20
%251 = load double, double* %250
%252 = load double, double* %17
%253 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %252, double %251)
%254 = load double, double* %13
%255 = fcmp oge double %253, %254
br i1 %255, label %256, label %315
256: ; preds = %249
%257 = load double*, double** %22
%258 = load double, double* %257
%259 = fcmp olt double %258, 0xD47D42AEA2879F2E
br i1 %259, label %260, label %271
260: ; preds = %256
%261 = load double*, double** %20
%262 = load double, double* %261
%263 = load double, double* %17
%264 = fadd double %262, %263
%265 = load double*, double** %22
store double %264, double* %265
%266 = load void (double, double*, i8*)*, void (double, double*, i8*)** %16
%267 = load double*, double** %22
%268 = load double, double* %267
%269 = load double*, double** %23
%270 = load i8*, i8** %24
br label %271
271: ; preds = %260, %256
%272 = load double*, double** %20
%273 = load double, double* %272
%274 = load double*, double** %18
store double %273, double* %274
%275 = load double*, double** %22
%276 = load double, double* %275
%277 = load double*, double** %20
store double %276, double* %277
store i32 0, i32* %25
br label %278
278: ; preds = %301, %271
%279 = load i32, i32* %25
%280 = load i32, i32* %15
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %304
282: ; preds = %278
%283 = load double*, double** %21
%284 = load i32, i32* %25
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %283, i64 %285
%287 = load double, double* %286
%288 = load double*, double** %19
%289 = load i32, i32* %25
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %288, i64 %290
store double %287, double* %291
%292 = load double*, double** %23
%293 = load i32, i32* %25
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %292, i64 %294
%296 = load double, double* %295
%297 = load double*, double** %21
%298 = load i32, i32* %25
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds double, double* %297, i64 %299
store double %296, double* %300
br label %301
301: ; preds = %282
%302 = load i32, i32* %25
%303 = add nsw i32 %302, 1
store i32 %303, i32* %25
br label %278
304: ; preds = %278
%305 = load double*, double** %20
%306 = load double, double* %305
%307 = load double, double* %17
%308 = fadd double %306, %307
%309 = load double*, double** %22
store double %308, double* %309
%310 = load void (double, double*, i8*)*, void (double, double*, i8*)** %16
%311 = load double*, double** %22
%312 = load double, double* %311
%313 = load double*, double** %23
%314 = load i8*, i8** %24
br label %343
315: ; preds = %249
%316 = load double*, double** %18
store double -1.000000e+100, double* %316
%317 = load double*, double** %22
store double -1.000000e+100, double* %317
%318 = load double, double* %13
%319 = load double*, double** %20
store double %318, double* %319
%320 = load void (double, double*, i8*)*, void (double, double*, i8*)** %16
%321 = load double*, double** %20
%322 = load double, double* %321
%323 = load double*, double** %21
%324 = load i8*, i8** %24
store i32 0, i32* %25
br label %325
325: ; preds = %339, %315
%326 = load i32, i32* %25
%327 = load i32, i32* %15
%328 = icmp slt i32 %326, %327
br i1 %328, label %329, label %342
329: ; preds = %325
%330 = load double*, double** %21
%331 = load i32, i32* %25
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds double, double* %330, i64 %332
%334 = load double, double* %333
%335 = load double*, double** %14
%336 = load i32, i32* %25
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds double, double* %335, i64 %337
store double %334, double* %338
br label %339
339: ; preds = %329
%340 = load i32, i32* %25
%341 = add nsw i32 %340, 1
store i32 %341, i32* %25
br label %325
342: ; preds = %325
br label %384
343: ; preds = %304
br label %344
344: ; preds = %343, %248
%345 = load double*, double** %22
%346 = load double, double* %345
%347 = load double, double* %13
%348 = fsub double %346, %347
store double %348, double* %29
%349 = load double, double* %13
%350 = load double*, double** %20
%351 = load double, double* %350
%352 = fsub double %349, %351
store double %352, double* %30
%353 = load double, double* %17
%354 = fdiv double 1.000000e+00, %353
store double %354, double* %31
store i32 0, i32* %25
br label %355
355: ; preds = %380, %344
%356 = load i32, i32* %25
%357 = load i32, i32* %15
%358 = icmp slt i32 %356, %357
br i1 %358, label %359, label %383
359: ; preds = %355
%360 = load double, double* %31
%361 = load double*, double** %21
%362 = load i32, i32* %25
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds double, double* %361, i64 %363
%365 = load double, double* %364
%366 = load double, double* %29
%367 = load double*, double** %23
%368 = load i32, i32* %25
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds double, double* %367, i64 %369
%371 = load double, double* %370
%372 = load double, double* %30
%373 = fmul double %371, %372
%374 = call double @llvm.fmuladd.f64(double %365, double %366, double %373)
%375 = fmul double %360, %374
%376 = load double*, double** %14
%377 = load i32, i32* %25
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds double, double* %376, i64 %378
store double %375, double* %379
br label %380
380: ; preds = %359
%381 = load i32, i32* %25
%382 = add nsw i32 %381, 1
store i32 %382, i32* %25
br label %355
383: ; preds = %355
br label %384
384: ; preds = %62, %184, %342, %383, %225
ret void
}

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