void runge_kutta_6(void (*f)(double *, double *, double *, double), int dim,
                   double dt, double *vars, double *params, double syn) {
  double apoyo[dim], retorno[dim], variables_hat[dim];
  double k[6][dim];
  int j;
  (*f)(vars, retorno, params, syn);
  for (j = 0; j < dim; ++j) {
    k[0][j] = dt * retorno[j];
    apoyo[j] = vars[j] + k[0][j] * 0.2;
  }
  (*f)(apoyo, retorno, params, syn);
  for (j = 0; j < dim; ++j) {
    k[1][j] = dt * retorno[j];
    apoyo[j] = vars[j] + k[0][j] * 0.075 + k[1][j] * 0.225;
  }
  (*f)(apoyo, retorno, params, syn);
  for (j = 0; j < dim; ++j) {
    k[2][j] = dt * retorno[j];
    apoyo[j] = vars[j] + k[0][j] * 0.3 - k[1][j] * 0.9 + k[2][j] * 1.2;
  }
  (*f)(apoyo, retorno, params, syn);
  for (j = 0; j < dim; ++j) {
    k[3][j] = dt * retorno[j];
    apoyo[j] = vars[j] + k[0][j] * 0.075 + k[1][j] * 0.675 - k[2][j] * 0.6 +
               k[2][j] * 0.75;
  }
  (*f)(apoyo, retorno, params, syn);
  for (j = 0; j < dim; ++j) {
    k[4][j] = dt * retorno[j];
    apoyo[j] = vars[j] + k[0][j] * 0.660493827160493 + k[1][j] * 2.5 -
               k[2][j] * 5.185185185185185 + k[3][j] * 3.888888888888889 -
               k[4][j] * 0.864197530864197;
  }
  (*f)(apoyo, retorno, params, syn);
  for (j = 0; j < dim; ++j) {
    k[5][j] = dt * retorno[j];
    apoyo[j] = vars[j] + k[0][j] * 0.1049382716049382 +
               k[2][j] * 0.3703703703703703 + k[3][j] * 0.2777777777777777 +
               k[4][j] * 0.2469135802469135;
  }
  for (j = 0; j < dim; ++j) {
    vars[j] += k[0][j] * 0.098765432098765 + k[2][j] * 0.396825396825396 +
               k[3][j] * 0.231481481481481 + k[4][j] * 0.308641975308641 -
               k[5][j] * 0.035714285714285;
  }
  return;
}


x86 assembly (clang, -O0):
<runge_kutta_6>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
mov    -0xc(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x80(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
lea    0xf(,%rax,8),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rsi
sub    %rcx,%rsi
mov    %rsi,-0x78(%rbp)
mov    %rsi,%rsp
mov    %rax,-0x48(%rbp)
mov    -0xc(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0xc(%rbp),%eax
mov    %rax,-0x70(%rbp)
mov    %rax,%rcx
shl    $0x4,%rcx
lea    (%rcx,%rcx,2),%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rdx
movsd  -0x30(%rbp),%xmm0
call   *%rax
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124d <runge_kutta_6+0x14d>
mov    -0x80(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rsi
movsd  -0x18(%rbp),%xmm0
movslq -0x5c(%rbp),%rdi
mulsd  (%rsi,%rdi,8),%xmm0
imul   $0x0,%rdx,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  %xmm0,(%rsi,%rdi,8)
mov    -0x20(%rbp),%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
imul   $0x0,%rdx,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x5c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movsd  0xe82(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11c4 <runge_kutta_6+0xc4>
mov    -0x78(%rbp),%rsi
mov    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rdx
movsd  -0x30(%rbp),%xmm0
call   *%rax
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    131e <runge_kutta_6+0x21e>
mov    -0x80(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rsi
movsd  -0x18(%rbp),%xmm0
movslq -0x5c(%rbp),%rdi
mulsd  (%rsi,%rdi,8),%xmm0
mov    %rdx,%rdi
shl    $0x0,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  %xmm0,(%rsi,%rdi,8)
mov    -0x20(%rbp),%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
imul   $0x0,%rdx,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
movsd  0xdad(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
shl    $0x0,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x5c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movsd  0xda9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    126b <runge_kutta_6+0x16b>
mov    -0x78(%rbp),%rsi
mov    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rdx
movsd  -0x30(%rbp),%xmm0
call   *%rax
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1430 <runge_kutta_6+0x330>
mov    -0x80(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rsi
movsd  -0x18(%rbp),%xmm0
movslq -0x5c(%rbp),%rdi
mulsd  (%rsi,%rdi,8),%xmm0
mov    %rdx,%rdi
shl    $0x1,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  %xmm0,(%rsi,%rdi,8)
mov    -0x20(%rbp),%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
imul   $0x0,%rdx,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
movsd  0xcf4(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    %rdx,%rdi
shl    $0x0,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
movq   %xmm1,%rsi
movabs $0x8000000000000000,%rdi
xor    %rdi,%rsi
movq   %rsi,%xmm1
movsd  0xcab(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
shl    $0x1,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x5c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movsd  0xc7f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    133c <runge_kutta_6+0x23c>
mov    -0x78(%rbp),%rsi
mov    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rdx
movsd  -0x30(%rbp),%xmm0
call   *%rax
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1569 <runge_kutta_6+0x469>
mov    -0x80(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rsi
movsd  -0x18(%rbp),%xmm0
movslq -0x5c(%rbp),%rdi
mulsd  (%rsi,%rdi,8),%xmm0
imul   $0x3,%rdx,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  %xmm0,(%rsi,%rdi,8)
mov    -0x20(%rbp),%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
imul   $0x0,%rdx,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
movsd  0xbcd(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    %rdx,%rdi
shl    $0x0,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
movsd  0xb9b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    %rdx,%rdi
shl    $0x1,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
movq   %xmm1,%rsi
movabs $0x8000000000000000,%rdi
xor    %rdi,%rsi
movq   %rsi,%xmm1
movsd  0xb52(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
shl    $0x1,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x5c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movsd  0xb26(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    144e <runge_kutta_6+0x34e>
mov    -0x78(%rbp),%rsi
mov    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rdx
movsd  -0x30(%rbp),%xmm0
call   *%rax
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16e3 <runge_kutta_6+0x5e3>
mov    -0x80(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rsi
movsd  -0x18(%rbp),%xmm0
movslq -0x5c(%rbp),%rdi
mulsd  (%rsi,%rdi,8),%xmm0
mov    %rdx,%rdi
shl    $0x2,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  %xmm0,(%rsi,%rdi,8)
mov    -0x20(%rbp),%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
imul   $0x0,%rdx,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
movsd  0xa71(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    %rdx,%rdi
shl    $0x0,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
movsd  0xa3f(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    %rdx,%rdi
shl    $0x1,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
movq   %xmm0,%rsi
movabs $0x8000000000000000,%rdi
xor    %rdi,%rsi
movq   %rsi,%xmm0
movsd  0x9f6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
imul   $0x3,%rdx,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
movsd  0x9c7(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
shl    $0x2,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x5c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
movsd  0x984(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1587 <runge_kutta_6+0x487>
mov    -0x78(%rbp),%rsi
mov    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rdx
movsd  -0x30(%rbp),%xmm0
call   *%rax
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1802 <runge_kutta_6+0x702>
mov    -0x80(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rsi
movsd  -0x18(%rbp),%xmm0
movslq -0x5c(%rbp),%rdi
mulsd  (%rsi,%rdi,8),%xmm0
imul   $0x5,%rdx,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  %xmm0,(%rsi,%rdi,8)
mov    -0x20(%rbp),%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
imul   $0x0,%rdx,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
movsd  0x8d2(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    %rdx,%rdi
shl    $0x1,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
movsd  0x8a0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
imul   $0x3,%rdx,%rdi
shl    $0x3,%rdi
mov    %rcx,%rsi
add    %rdi,%rsi
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
movsd  0x871(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
shl    $0x2,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x5c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movsd  0x845(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1701 <runge_kutta_6+0x601>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1912 <runge_kutta_6+0x812>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
imul   $0x0,%rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x5c(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm1
mov    %rcx,%rsi
shl    $0x1,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x5c(%rbp),%rsi
movsd  0x7cf(%rip),%xmm0
mulsd  (%rdx,%rsi,8),%xmm0
movsd  0x7ba(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
imul   $0x3,%rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x5c(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  0x78b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    %rcx,%rsi
shl    $0x2,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x5c(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm1
movsd  0x759(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
imul   $0x5,%rcx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x716(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1809 <runge_kutta_6+0x709>
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<runge_kutta_6>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rcx,%r13
movaps %xmm0,-0x60(%rbp)
mov    %esi,-0x34(%rbp)
mov    %rdi,%r15
mov    %esi,%ebx
mov    %rsp,%r12
lea    0xf(,%rbx,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r12
mov    %r12,%rsp
mov    %rsp,%r14
sub    %rax,%r14
mov    %r14,%rsp
mov    %rsp,%rcx
mov    %rbx,%rax
shl    $0x4,%rax
mov    %rax,-0xa8(%rbp)
lea    (%rax,%rax,2),%rax
sub    %rax,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    %rdx,-0x40(%rbp)
mov    %rdx,%rdi
mov    %r14,%rsi
mov    %r13,%rdx
movsd  %xmm1,-0x30(%rbp)
movapd %xmm1,%xmm0
call   *%r15
mov    -0x34(%rbp),%eax
test   %eax,%eax
jle    11a6 <runge_kutta_6+0xa6>
mov    %r13,-0x70(%rbp)
mov    %r15,-0x78(%rbp)
cmp    $0x1,%eax
jne    11bc <runge_kutta_6+0xbc>
xor    %eax,%eax
movapd -0x60(%rbp),%xmm4
movsd  -0x30(%rbp),%xmm0
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rdx
jmp    128f <runge_kutta_6+0x18f>
mov    %r12,%rdi
mov    %r14,%rsi
mov    %r13,%rdx
movsd  -0x30(%rbp),%xmm0
call   *%r15
jmp    130b <runge_kutta_6+0x20b>
mov    %ebx,%eax
and    $0xfffffffe,%eax
movapd -0x60(%rbp),%xmm4
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
lea    -0x2(%rax),%rcx
mov    %rcx,%r8
shr    %r8
add    $0x1,%r8
test   %rcx,%rcx
movsd  -0x30(%rbp),%xmm0
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rdx
je     1421 <runge_kutta_6+0x321>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movapd 0xdfd(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd (%r14,%rcx,8),%xmm2
mulpd  %xmm5,%xmm2
movapd %xmm2,(%rdx,%rcx,8)
movupd (%rdi,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movapd %xmm2,(%r12,%rcx,8)
movapd 0x10(%r14,%rcx,8),%xmm2
mulpd  %xmm5,%xmm2
movapd %xmm2,0x10(%rdx,%rcx,8)
movupd 0x10(%rdi,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movapd %xmm2,0x10(%r12,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1210 <runge_kutta_6+0x110>
test   $0x1,%r8b
je     128a <runge_kutta_6+0x18a>
mulpd  (%r14,%rcx,8),%xmm5
movapd %xmm5,(%rdx,%rcx,8)
movupd (%rdi,%rcx,8),%xmm1
mulpd  0xd80(%rip),%xmm5
addpd  %xmm1,%xmm5
movapd %xmm5,(%r12,%rcx,8)
cmp    %rbx,%rax
je     12c7 <runge_kutta_6+0x1c7>
movsd  0xed9(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
mulsd  %xmm2,%xmm1
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    12a0 <runge_kutta_6+0x1a0>
mov    %r12,%rdi
mov    %r14,%rsi
mov    -0x70(%rbp),%r13
mov    %r13,%rdx
mov    -0x78(%rbp),%r15
call   *%r15
mov    -0x34(%rbp),%eax
test   %eax,%eax
jle    130b <runge_kutta_6+0x20b>
mov    -0x50(%rbp),%rdx
lea    (%rdx,%rbx,8),%r10
cmp    $0x1,%eax
mov    %r10,-0x98(%rbp)
jne    135e <runge_kutta_6+0x25e>
xor    %eax,%eax
movapd -0x60(%rbp),%xmm6
movsd  -0x30(%rbp),%xmm0
mov    -0x40(%rbp),%r8
jmp    147d <runge_kutta_6+0x37d>
mov    %r12,%rdi
mov    %r14,%rsi
mov    %r13,%rdx
movsd  -0x30(%rbp),%xmm0
call   *%r15
mov    %r12,%rdi
mov    %r14,%rsi
mov    %r13,%rdx
movsd  -0x30(%rbp),%xmm0
call   *%r15
mov    %r12,%rdi
mov    %r14,%rsi
mov    %r13,%rdx
movsd  -0x30(%rbp),%xmm0
call   *%r15
mov    %r12,%rdi
mov    %r14,%rsi
mov    %r13,%rdx
movsd  -0x30(%rbp),%xmm0
call   *%r15
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ebx,%eax
and    $0xfffffffe,%eax
movapd -0x60(%rbp),%xmm6
movapd %xmm6,%xmm7
unpcklpd %xmm6,%xmm7
lea    -0x2(%rax),%rcx
mov    %rcx,%r9
shr    %r9
add    $0x1,%r9
test   %rcx,%rcx
je     1432 <runge_kutta_6+0x332>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rdx,%rbx,8),%rdi
add    $0x10,%rdi
xor    %ecx,%ecx
movapd 0xc70(%rip),%xmm1
movapd 0xc78(%rip),%xmm2
mov    -0x40(%rbp),%r8
nopl   0x0(%rax)
movapd (%r14,%rcx,8),%xmm3
mulpd  %xmm7,%xmm3
movupd %xmm3,-0x10(%rdi,%rcx,8)
movupd (%r8,%rcx,8),%xmm4
movapd (%rdx,%rcx,8),%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm4,%xmm5
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
movapd %xmm3,(%r12,%rcx,8)
movapd 0x10(%r14,%rcx,8),%xmm3
mulpd  %xmm7,%xmm3
movupd %xmm3,(%rdi,%rcx,8)
movupd 0x10(%r8,%rcx,8),%xmm4
movapd 0x10(%rdx,%rcx,8),%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm4,%xmm5
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
movapd %xmm3,0x10(%r12,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rsi
jne    13b0 <runge_kutta_6+0x2b0>
jmp    1438 <runge_kutta_6+0x338>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1268 <runge_kutta_6+0x168>
jmp    128a <runge_kutta_6+0x18a>
xor    %ecx,%ecx
mov    -0x40(%rbp),%r8
test   $0x1,%r9b
movsd  -0x30(%rbp),%xmm0
je     1478 <runge_kutta_6+0x378>
mulpd  (%r14,%rcx,8),%xmm7
movupd %xmm7,(%r10,%rcx,8)
movupd (%r8,%rcx,8),%xmm1
movapd (%rdx,%rcx,8),%xmm2
mulpd  0xbae(%rip),%xmm2
addpd  %xmm1,%xmm2
mulpd  0xbb2(%rip),%xmm7
addpd  %xmm2,%xmm7
movapd %xmm7,(%r12,%rcx,8)
cmp    %rbx,%rax
je     14dc <runge_kutta_6+0x3dc>
lea    (%r12,%rax,8),%rcx
lea    (%rdx,%rax,8),%rdx
lea    (%r8,%rax,8),%rsi
movsd  0xce7(%rip),%xmm4
movsd  0xce7(%rip),%xmm1
nopl   0x0(%rax)
movsd  (%r14,%rax,8),%xmm2
mulsd  %xmm6,%xmm2
movsd  %xmm2,(%rdx,%rbx,8)
movsd  (%rdx),%xmm3
mulsd  %xmm4,%xmm3
addsd  (%rsi),%xmm3
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rcx)
add    $0x1,%rax
add    $0x8,%rcx
add    $0x8,%rdx
add    $0x8,%rsi
cmp    %rax,%rbx
jne    14a0 <runge_kutta_6+0x3a0>
mov    %r12,%rdi
mov    %r14,%rsi
mov    -0x70(%rbp),%r13
mov    %r13,%rdx
mov    -0x78(%rbp),%r15
call   *%r15
mov    -0x34(%rbp),%ecx
test   %ecx,%ecx
jle    131c <runge_kutta_6+0x21c>
lea    (%rbx,%rbx,1),%rax
mov    %rax,-0x68(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0x50(%rbp),%r11
lea    (%r11,%rax,1),%rsi
cmp    $0x1,%ecx
mov    %rbx,-0x48(%rbp)
mov    %rsi,-0x90(%rbp)
jne    1533 <runge_kutta_6+0x433>
xor    %r8d,%r8d
movapd -0x60(%rbp),%xmm7
mov    -0x40(%rbp),%rdx
jmp    15bf <runge_kutta_6+0x4bf>
mov    %ebx,%r8d
and    $0xfffffffe,%r8d
movapd -0x60(%rbp),%xmm7
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
xor    %eax,%eax
movapd 0xadf(%rip),%xmm1
movapd 0xae7(%rip),%xmm2
movapd 0xaef(%rip),%xmm3
mov    -0x40(%rbp),%rdx
mov    -0x98(%rbp),%rcx
nopl   0x0(%rax)
movapd (%r14,%rax,8),%xmm4
mulpd  %xmm0,%xmm4
movapd %xmm4,(%rsi,%rax,8)
movupd (%rdx,%rax,8),%xmm5
movapd (%r11,%rax,8),%xmm6
mulpd  %xmm1,%xmm6
addpd  %xmm5,%xmm6
movupd (%rcx,%rax,8),%xmm5
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movapd %xmm4,(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%r8
jne    1570 <runge_kutta_6+0x470>
cmp    %rbx,%r8
je     1651 <runge_kutta_6+0x551>
lea    (%r12,%r8,8),%r9
mov    -0x48(%rbp),%rcx
lea    (%r8,%rcx,1),%rax
lea    (%r11,%rax,8),%r10
lea    (%r11,%r8,8),%rsi
lea    (%rdx,%r8,8),%rdi
mov    -0x68(%rbp),%rax
add    %r8,%rax
lea    (%r11,%rax,8),%rax
lea    (%r14,%r8,8),%rbx
sub    %r8,%rcx
xor    %edx,%edx
movsd  0xb95(%rip),%xmm0
movsd  0xb95(%rip),%xmm1
movsd  0xb95(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rdx,8),%xmm3
mulsd  %xmm7,%xmm3
movsd  %xmm3,(%rax,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  (%rdi,%rdx,8),%xmm4
movsd  (%r10,%rdx,8),%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm3
addsd  %xmm5,%xmm3
movsd  %xmm3,(%r9,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1610 <runge_kutta_6+0x510>
mov    %r12,%rdi
mov    %r14,%rsi
mov    -0x70(%rbp),%r13
mov    %r13,%rdx
movsd  -0x30(%rbp),%xmm0
mov    -0x78(%rbp),%r15
call   *%r15
mov    -0x34(%rbp),%eax
test   %eax,%eax
jle    132d <runge_kutta_6+0x22d>
mov    -0x48(%rbp),%rbx
lea    (%rbx,%rbx,2),%rcx
mov    -0x50(%rbp),%r15
mov    %rcx,-0x80(%rbp)
lea    (%r15,%rcx,8),%rdx
cmp    $0x1,%eax
mov    %rdx,-0xa0(%rbp)
jne    16ab <runge_kutta_6+0x5ab>
xor    %edi,%edi
movapd -0x60(%rbp),%xmm8
movsd  -0x30(%rbp),%xmm0
mov    -0x40(%rbp),%rcx
jmp    1769 <runge_kutta_6+0x669>
mov    %ebx,%edi
and    $0xfffffffe,%edi
movapd -0x60(%rbp),%xmm8
movapd %xmm8,%xmm0
unpcklpd %xmm8,%xmm0
xor    %eax,%eax
movapd 0x946(%rip),%xmm1
movapd 0x98e(%rip),%xmm2
movapd 0x996(%rip),%xmm3
movapd 0x99e(%rip),%xmm4
mov    -0x40(%rbp),%rcx
mov    -0x98(%rbp),%rsi
mov    -0x90(%rbp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd (%r14,%rax,8),%xmm5
mulpd  %xmm0,%xmm5
movupd %xmm5,(%rdx,%rax,8)
movupd (%rcx,%rax,8),%xmm5
movapd (%r15,%rax,8),%xmm6
mulpd  %xmm1,%xmm6
addpd  %xmm5,%xmm6
movupd (%rsi,%rax,8),%xmm5
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
movapd (%rbx,%rax,8),%xmm6
movapd %xmm6,%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm5,%xmm7
mulpd  %xmm4,%xmm6
addpd  %xmm7,%xmm6
movapd %xmm6,(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1700 <runge_kutta_6+0x600>
mov    -0x48(%rbp),%rbx
cmp    %rbx,%rdi
movsd  -0x30(%rbp),%xmm0
je     1815 <runge_kutta_6+0x715>
lea    (%r12,%rdi,8),%r9
mov    -0x68(%rbp),%rax
add    %rdi,%rax
lea    (%r15,%rax,8),%r10
lea    (%rdi,%rbx,1),%rax
lea    (%r15,%rax,8),%r11
lea    (%r15,%rdi,8),%r8
lea    (%rcx,%rdi,8),%rax
mov    -0x80(%rbp),%rcx
add    %rdi,%rcx
lea    (%r15,%rcx,8),%rcx
lea    (%r14,%rdi,8),%rdx
mov    %rbx,%rsi
sub    %rdi,%rsi
xor    %edi,%edi
movsd  0x9d1(%rip),%xmm7
movsd  0x9f1(%rip),%xmm1
movsd  0x9f1(%rip),%xmm2
movsd  0x9f1(%rip),%xmm3
nop
movsd  (%rdx,%rdi,8),%xmm4
mulsd  %xmm8,%xmm4
movsd  %xmm4,(%rcx,%rdi,8)
movsd  (%r8,%rdi,8),%xmm4
mulsd  %xmm7,%xmm4
addsd  (%rax,%rdi,8),%xmm4
movsd  (%r11,%rdi,8),%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
movsd  (%r10,%rdi,8),%xmm4
movapd %xmm4,%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm3,%xmm4
addsd  %xmm6,%xmm4
movsd  %xmm4,(%r9,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    17c0 <runge_kutta_6+0x6c0>
mov    %r12,%rdi
mov    %r14,%rsi
mov    -0x70(%rbp),%r13
mov    %r13,%rdx
mov    -0x78(%rbp),%r15
call   *%r15
mov    -0x34(%rbp),%eax
test   %eax,%eax
jle    133e <runge_kutta_6+0x23e>
lea    0x0(,%rbx,4),%rcx
mov    %rcx,-0x88(%rbp)
mov    %rbx,%rcx
shl    $0x5,%rcx
mov    -0x50(%rbp),%r13
mov    %rcx,-0xb0(%rbp)
lea    (%rcx,%r13,1),%rdi
cmp    $0x1,%eax
mov    -0x98(%rbp),%rcx
mov    %rdi,-0xb8(%rbp)
jne    187d <runge_kutta_6+0x77d>
xor    %ebx,%ebx
movapd -0x60(%rbp),%xmm9
mov    -0x40(%rbp),%r15
jmp    193d <runge_kutta_6+0x83d>
mov    %rbx,%rdx
and    $0xfffffffe,%ebx
movapd -0x60(%rbp),%xmm9
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
xor    %eax,%eax
movapd 0x7f2(%rip),%xmm8
movapd 0x7fa(%rip),%xmm2
movapd 0x802(%rip),%xmm3
movapd 0x80a(%rip),%xmm4
movapd 0x812(%rip),%xmm5
mov    -0x40(%rbp),%r15
mov    -0x90(%rbp),%rdx
mov    -0xa0(%rbp),%rsi
movapd (%r14,%rax,8),%xmm6
mulpd  %xmm0,%xmm6
movapd %xmm6,(%rdi,%rax,8)
movupd (%r15,%rax,8),%xmm7
movapd 0x0(%r13,%rax,8),%xmm1
mulpd  %xmm8,%xmm1
addpd  %xmm7,%xmm1
movupd (%rcx,%rax,8),%xmm7
mulpd  %xmm2,%xmm7
addpd  %xmm1,%xmm7
movapd (%rdx,%rax,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm7,%xmm1
movupd (%rsi,%rax,8),%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm1,%xmm7
mulpd  %xmm5,%xmm6
addpd  %xmm7,%xmm6
movapd %xmm6,(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    18d0 <runge_kutta_6+0x7d0>
cmp    -0x48(%rbp),%rbx
je     1a22 <runge_kutta_6+0x922>
lea    (%r12,%rbx,8),%r9
mov    -0x80(%rbp),%rax
add    %rbx,%rax
lea    0x0(%r13,%rax,8),%r10
mov    -0x68(%rbp),%rax
lea    (%rbx,%rax,1),%rax
lea    0x0(%r13,%rax,8),%r11
mov    -0x48(%rbp),%r8
lea    (%rbx,%r8,1),%rax
lea    0x0(%r13,%rax,8),%rdi
lea    0x0(%r13,%rbx,8),%rax
lea    (%r15,%rbx,8),%rcx
mov    -0x88(%rbp),%rdx
add    %rbx,%rdx
lea    0x0(,%rdx,8),%rdx
add    %r13,%rdx
lea    (%r14,%rbx,8),%rsi
sub    %rbx,%r8
mov    %r9,%rbx
xor    %r9d,%r9d
movsd  0x81e(%rip),%xmm0
movsd  0x81e(%rip),%xmm1
movsd  0x81e(%rip),%xmm2
movsd  0x81e(%rip),%xmm3
movsd  0x81e(%rip),%xmm4
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%r9,8),%xmm5
mulsd  %xmm9,%xmm5
movsd  %xmm5,(%rdx,%r9,8)
movsd  (%rax,%r9,8),%xmm6
mulsd  %xmm0,%xmm6
addsd  (%rcx,%r9,8),%xmm6
movsd  (%rdi,%r9,8),%xmm7
mulsd  %xmm1,%xmm7
addsd  %xmm6,%xmm7
movsd  (%r11,%r9,8),%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm7,%xmm6
movsd  (%r10,%r9,8),%xmm7
mulsd  %xmm3,%xmm7
addsd  %xmm6,%xmm7
mulsd  %xmm4,%xmm5
addsd  %xmm7,%xmm5
movsd  %xmm5,(%rbx,%r9,8)
add    $0x1,%r9
cmp    %r9,%r8
jne    19c0 <runge_kutta_6+0x8c0>
mov    %r12,%rdi
mov    %r14,%rsi
mov    -0x70(%rbp),%rdx
movsd  -0x30(%rbp),%xmm0
call   *-0x78(%rbp)
mov    -0x34(%rbp),%eax
test   %eax,%eax
mov    -0x48(%rbp),%rbx
jle    134f <runge_kutta_6+0x24f>
lea    (%rbx,%rbx,4),%rcx
cmp    $0x1,%eax
mov    %rbx,%rdx
mov    -0x90(%rbp),%rsi
mov    -0xa0(%rbp),%rdi
mov    -0xb8(%rbp),%rbx
mov    %rcx,-0x30(%rbp)
jne    1a75 <runge_kutta_6+0x975>
xor    %r9d,%r9d
movapd -0x60(%rbp),%xmm7
jmp    1b23 <runge_kutta_6+0xa23>
lea    0x0(,%rcx,8),%rax
add    %r13,%rax
mov    %edx,%r9d
and    $0xfffffffe,%r9d
movapd -0x60(%rbp),%xmm7
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
xor    %ecx,%ecx
movapd 0x642(%rip),%xmm1
movapd 0x64a(%rip),%xmm2
movapd 0x652(%rip),%xmm3
movapd 0x65a(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
movapd (%r14,%rcx,8),%xmm5
mulpd  %xmm0,%xmm5
movupd %xmm5,(%rax,%rcx,8)
movupd (%r15,%rcx,8),%xmm5
movapd 0x0(%r13,%rcx,8),%xmm6
mulpd  %xmm1,%xmm6
addpd  %xmm5,%xmm6
movapd (%rsi,%rcx,8),%xmm5
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
movupd (%rdi,%rcx,8),%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm5,%xmm6
movapd (%rbx,%rcx,8),%xmm5
mulpd  %xmm4,%xmm5
addpd  %xmm6,%xmm5
movapd %xmm5,(%r12,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1ac0 <runge_kutta_6+0x9c0>
cmp    %rdx,%r9
je     1bf5 <runge_kutta_6+0xaf5>
lea    (%r12,%r9,8),%r10
mov    -0x88(%rbp),%rax
add    %r9,%rax
lea    0x0(%r13,%rax,8),%r11
mov    -0x80(%rbp),%rax
lea    (%r9,%rax,1),%rax
lea    0x0(%r13,%rax,8),%r12
mov    -0x68(%rbp),%rax
add    %r9,%rax
lea    0x0(%r13,%rax,8),%r8
lea    0x0(%r13,%r9,8),%rcx
lea    (%r15,%r9,8),%rdx
mov    -0x30(%rbp),%rax
add    %r9,%rax
lea    0x0(,%rax,8),%rsi
add    %r13,%rsi
lea    (%r14,%r9,8),%rbx
mov    -0x48(%rbp),%rdi
sub    %r9,%rdi
xor    %eax,%eax
movsd  0x661(%rip),%xmm0
movsd  0x661(%rip),%xmm1
movsd  0x661(%rip),%xmm2
movsd  0x661(%rip),%xmm3
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm4
mulsd  %xmm7,%xmm4
movsd  %xmm4,(%rsi,%rax,8)
movsd  (%rcx,%rax,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  (%rdx,%rax,8),%xmm4
movsd  (%r8,%rax,8),%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
movsd  (%r12,%rax,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movsd  (%r11,%rax,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%r10,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1ba0 <runge_kutta_6+0xaa0>
mov    -0x34(%rbp),%eax
test   %eax,%eax
jle    134f <runge_kutta_6+0x24f>
cmp    $0x1,%eax
jne    1c11 <runge_kutta_6+0xb11>
xor    %r9d,%r9d
mov    -0x48(%rbp),%r10
jmp    1cd2 <runge_kutta_6+0xbd2>
mov    -0x48(%rbp),%r10
mov    %r10d,%r9d
and    $0xfffffffe,%r9d
lea    0x0(,%r10,8),%rax
lea    (%rax,%rax,2),%rdx
lea    (%rax,%rax,4),%rax
xor    %esi,%esi
movapd 0x4ea(%rip),%xmm0
movapd 0x4f2(%rip),%xmm1
movapd 0x4fa(%rip),%xmm2
movapd 0x502(%rip),%xmm3
movapd 0x50a(%rip),%xmm4
mov    %r13,%rcx
mov    -0xa8(%rbp),%rbx
mov    -0xb0(%rbp),%rdi
nopw   0x0(%rax,%rax,1)
movapd (%rcx,%rbx,1),%xmm5
mulpd  %xmm0,%xmm5
movapd (%rcx),%xmm6
mulpd  %xmm1,%xmm6
addpd  %xmm5,%xmm6
movupd (%rcx,%rdx,1),%xmm5
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
movapd (%rcx,%rdi,1),%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm5,%xmm6
movupd (%rcx,%rax,1),%xmm5
mulpd  %xmm4,%xmm5
addpd  %xmm6,%xmm5
movupd (%r15,%rsi,8),%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%r15,%rsi,8)
add    $0x2,%rsi
add    $0x10,%rcx
cmp    %rsi,%r9
jne    1c70 <runge_kutta_6+0xb70>
cmp    %r10,%r9
je     134f <runge_kutta_6+0x24f>
lea    (%r15,%r9,8),%rdx
mov    -0x30(%rbp),%rax
add    %r9,%rax
lea    0x0(,%rax,8),%r8
add    %r13,%r8
mov    -0x88(%rbp),%rax
add    %r9,%rax
lea    0x0(,%rax,8),%rsi
add    %r13,%rsi
mov    -0x80(%rbp),%rax
add    %r9,%rax
lea    0x0(,%rax,8),%rdi
add    %r13,%rdi
mov    -0x68(%rbp),%rax
add    %r9,%rax
lea    0x0(,%rax,8),%rbx
add    %r13,%rbx
lea    0x0(,%r9,8),%rcx
add    %r13,%rcx
sub    %r9,%r10
xor    %eax,%eax
movsd  0x4c7(%rip),%xmm0
movsd  0x4c7(%rip),%xmm1
movsd  0x4c7(%rip),%xmm2
movsd  0x4c7(%rip),%xmm3
movsd  0x4c7(%rip),%xmm4
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm5
mulsd  %xmm0,%xmm5
movsd  (%rcx,%rax,8),%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm5,%xmm6
movsd  (%rdi,%rax,8),%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm6,%xmm5
movsd  (%rsi,%rax,8),%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
movsd  (%r8,%rax,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm6,%xmm5
addsd  (%rdx,%rax,8),%xmm5
movsd  %xmm5,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    1d60 <runge_kutta_6+0xc60>
jmp    134f <runge_kutta_6+0x24f>

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

LLVM IR (-O2):
define void @runge_kutta_6(void (double*, double*, double*, double)* nocapture %0, i32 %1, double %2, double* %3, double* %4, double %5) {
%7 = zext i32 %1 to i64
%8 = alloca double, i64 %7
%9 = alloca double, i64 %7
%10 = mul nuw nsw i64 %7, 6
%11 = alloca double, i64 %10
%12 = icmp sgt i32 %1, 0
br i1 %12, label %13, label %77
13: ; preds = %6
%14 = icmp eq i32 %1, 1
br i1 %14, label %75, label %15
15: ; preds = %13
%16 = and i64 %7, 4294967294
%17 = insertelement <2 x double> poison, double %2, i64 0
%18 = shufflevector <2 x double> %17, <2 x double> poison, <2 x i32> zeroinitializer
%19 = add nsw i64 %16, -2
%20 = lshr exact i64 %19, 1
%21 = add nuw i64 %20, 1
%22 = and i64 %21, 1
%23 = icmp eq i64 %19, 0
br i1 %23, label %57, label %24
24: ; preds = %15
%25 = and i64 %21, -2
br label %26
26: ; preds = %26, %24
%27 = phi i64 [ 0, %24 ], [ %54, %26 ]
%28 = phi i64 [ 0, %24 ], [ %55, %26 ]
%29 = getelementptr inbounds double, double* %9, i64 %27
%30 = bitcast double* %29 to <2 x double>*
%31 = load <2 x double>, <2 x double>* %30
%32 = fmul <2 x double> %31, %18
%33 = getelementptr inbounds double, double* %11, i64 %27
%34 = bitcast double* %33 to <2 x double>*
store <2 x double> %32, <2 x double>* %34
%35 = getelementptr inbounds double, double* %3, i64 %27
%36 = bitcast double* %35 to <2 x double>*
%37 = load <2 x double>, <2 x double>* %36
%38 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %32, <2 x double> <double 2.000000e-01, double 2.000000e-01>, <2 x double> %37)
%39 = getelementptr inbounds double, double* %8, i64 %27
%40 = bitcast double* %39 to <2 x double>*
store <2 x double> %38, <2 x double>* %40
%41 = or i64 %27, 2
%42 = getelementptr inbounds double, double* %9, i64 %41
%43 = bitcast double* %42 to <2 x double>*
%44 = load <2 x double>, <2 x double>* %43
%45 = fmul <2 x double> %44, %18
%46 = getelementptr inbounds double, double* %11, i64 %41
%47 = bitcast double* %46 to <2 x double>*
store <2 x double> %45, <2 x double>* %47
%48 = getelementptr inbounds double, double* %3, i64 %41
%49 = bitcast double* %48 to <2 x double>*
%50 = load <2 x double>, <2 x double>* %49
%51 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %45, <2 x double> <double 2.000000e-01, double 2.000000e-01>, <2 x double> %50)
%52 = getelementptr inbounds double, double* %8, i64 %41
%53 = bitcast double* %52 to <2 x double>*
store <2 x double> %51, <2 x double>* %53
%54 = add nuw i64 %27, 4
%55 = add nuw i64 %28, 2
%56 = icmp eq i64 %55, %25
br i1 %56, label %57, label %26
57: ; preds = %26, %15
%58 = phi i64 [ 0, %15 ], [ %54, %26 ]
%59 = icmp eq i64 %22, 0
br i1 %59, label %73, label %60
60: ; preds = %57
%61 = getelementptr inbounds double, double* %9, i64 %58
%62 = bitcast double* %61 to <2 x double>*
%63 = load <2 x double>, <2 x double>* %62
%64 = fmul <2 x double> %63, %18
%65 = getelementptr inbounds double, double* %11, i64 %58
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> %64, <2 x double>* %66
%67 = getelementptr inbounds double, double* %3, i64 %58
%68 = bitcast double* %67 to <2 x double>*
%69 = load <2 x double>, <2 x double>* %68
%70 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %64, <2 x double> <double 2.000000e-01, double 2.000000e-01>, <2 x double> %69)
%71 = getelementptr inbounds double, double* %8, i64 %58
%72 = bitcast double* %71 to <2 x double>*
store <2 x double> %70, <2 x double>* %72
br label %73
73: ; preds = %57, %60
%74 = icmp eq i64 %16, %7
br i1 %74, label %90, label %75
75: ; preds = %13, %73
%76 = phi i64 [ 0, %13 ], [ %16, %73 ]
br label %78
77: ; preds = %6
br label %183
78: ; preds = %75, %78
%79 = phi i64 [ %88, %78 ], [ %76, %75 ]
%80 = getelementptr inbounds double, double* %9, i64 %79
%81 = load double, double* %80
%82 = fmul double %81, %2
%83 = getelementptr inbounds double, double* %11, i64 %79
store double %82, double* %83
%84 = getelementptr inbounds double, double* %3, i64 %79
%85 = load double, double* %84
%86 = call double @llvm.fmuladd.f64(double %82, double 2.000000e-01, double %85)
%87 = getelementptr inbounds double, double* %8, i64 %79
store double %86, double* %87
%88 = add nuw nsw i64 %79, 1
%89 = icmp eq i64 %88, %7
br i1 %89, label %90, label %78
90: ; preds = %78, %73
br i1 %12, label %91, label %183
91: ; preds = %90
%92 = getelementptr inbounds double, double* %11, i64 %7
%93 = icmp eq i32 %1, 1
br i1 %93, label %166, label %94
94: ; preds = %91
%95 = and i64 %7, 4294967294
%96 = insertelement <2 x double> poison, double %2, i64 0
%97 = shufflevector <2 x double> %96, <2 x double> poison, <2 x i32> zeroinitializer
%98 = add nsw i64 %95, -2
%99 = lshr exact i64 %98, 1
%100 = add nuw i64 %99, 1
%101 = and i64 %100, 1
%102 = icmp eq i64 %98, 0
br i1 %102, label %144, label %103
103: ; preds = %94
%104 = and i64 %100, -2
br label %105
105: ; preds = %105, %103
%106 = phi i64 [ 0, %103 ], [ %141, %105 ]
%107 = phi i64 [ 0, %103 ], [ %142, %105 ]
%108 = getelementptr inbounds double, double* %9, i64 %106
%109 = bitcast double* %108 to <2 x double>*
%110 = load <2 x double>, <2 x double>* %109
%111 = fmul <2 x double> %110, %97
%112 = getelementptr inbounds double, double* %92, i64 %106
%113 = bitcast double* %112 to <2 x double>*
store <2 x double> %111, <2 x double>* %113
%114 = getelementptr inbounds double, double* %3, i64 %106
%115 = bitcast double* %114 to <2 x double>*
%116 = load <2 x double>, <2 x double>* %115
%117 = getelementptr inbounds double, double* %11, i64 %106
%118 = bitcast double* %117 to <2 x double>*
%119 = load <2 x double>, <2 x double>* %118
%120 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %119, <2 x double> <double 0x3FB3333333333333, double 0x3FB3333333333333>, <2 x double> %116)
%121 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %111, <2 x double> <double 2.250000e-01, double 2.250000e-01>, <2 x double> %120)
%122 = getelementptr inbounds double, double* %8, i64 %106
%123 = bitcast double* %122 to <2 x double>*
store <2 x double> %121, <2 x double>* %123
%124 = or i64 %106, 2
%125 = getelementptr inbounds double, double* %9, i64 %124
%126 = bitcast double* %125 to <2 x double>*
%127 = load <2 x double>, <2 x double>* %126
%128 = fmul <2 x double> %127, %97
%129 = getelementptr inbounds double, double* %92, i64 %124
%130 = bitcast double* %129 to <2 x double>*
store <2 x double> %128, <2 x double>* %130
%131 = getelementptr inbounds double, double* %3, i64 %124
%132 = bitcast double* %131 to <2 x double>*
%133 = load <2 x double>, <2 x double>* %132
%134 = getelementptr inbounds double, double* %11, i64 %124
%135 = bitcast double* %134 to <2 x double>*
%136 = load <2 x double>, <2 x double>* %135
%137 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %136, <2 x double> <double 0x3FB3333333333333, double 0x3FB3333333333333>, <2 x double> %133)
%138 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %128, <2 x double> <double 2.250000e-01, double 2.250000e-01>, <2 x double> %137)
%139 = getelementptr inbounds double, double* %8, i64 %124
%140 = bitcast double* %139 to <2 x double>*
store <2 x double> %138, <2 x double>* %140
%141 = add nuw i64 %106, 4
%142 = add nuw i64 %107, 2
%143 = icmp eq i64 %142, %104
br i1 %143, label %144, label %105
144: ; preds = %105, %94
%145 = phi i64 [ 0, %94 ], [ %141, %105 ]
%146 = icmp eq i64 %101, 0
br i1 %146, label %164, label %147
147: ; preds = %144
%148 = getelementptr inbounds double, double* %9, i64 %145
%149 = bitcast double* %148 to <2 x double>*
%150 = load <2 x double>, <2 x double>* %149
%151 = fmul <2 x double> %150, %97
%152 = getelementptr inbounds double, double* %92, i64 %145
%153 = bitcast double* %152 to <2 x double>*
store <2 x double> %151, <2 x double>* %153
%154 = getelementptr inbounds double, double* %3, i64 %145
%155 = bitcast double* %154 to <2 x double>*
%156 = load <2 x double>, <2 x double>* %155
%157 = getelementptr inbounds double, double* %11, i64 %145
%158 = bitcast double* %157 to <2 x double>*
%159 = load <2 x double>, <2 x double>* %158
%160 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %159, <2 x double> <double 0x3FB3333333333333, double 0x3FB3333333333333>, <2 x double> %156)
%161 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %151, <2 x double> <double 2.250000e-01, double 2.250000e-01>, <2 x double> %160)
%162 = getelementptr inbounds double, double* %8, i64 %145
%163 = bitcast double* %162 to <2 x double>*
store <2 x double> %161, <2 x double>* %163
br label %164
164: ; preds = %144, %147
%165 = icmp eq i64 %95, %7
br i1 %165, label %184, label %166
166: ; preds = %91, %164
%167 = phi i64 [ 0, %91 ], [ %95, %164 ]
br label %168
168: ; preds = %166, %168
%169 = phi i64 [ %181, %168 ], [ %167, %166 ]
%170 = getelementptr inbounds double, double* %9, i64 %169
%171 = load double, double* %170
%172 = fmul double %171, %2
%173 = getelementptr inbounds double, double* %92, i64 %169
store double %172, double* %173
%174 = getelementptr inbounds double, double* %3, i64 %169
%175 = load double, double* %174
%176 = getelementptr inbounds double, double* %11, i64 %169
%177 = load double, double* %176
%178 = call double @llvm.fmuladd.f64(double %177, double 0x3FB3333333333333, double %175)
%179 = call double @llvm.fmuladd.f64(double %172, double 2.250000e-01, double %178)
%180 = getelementptr inbounds double, double* %8, i64 %169
store double %179, double* %180
%181 = add nuw nsw i64 %169, 1
%182 = icmp eq i64 %181, %7
br i1 %182, label %184, label %168
183: ; preds = %77, %90
br label %242
184: ; preds = %168, %164
br i1 %12, label %185, label %242
185: ; preds = %184
%186 = shl nuw nsw i64 %7, 1
%187 = getelementptr inbounds double, double* %11, i64 %186
%188 = getelementptr inbounds double, double* %11, i64 %7
%189 = icmp eq i32 %1, 1
br i1 %189, label %221, label %190
190: ; preds = %185
%191 = and i64 %7, 4294967294
%192 = insertelement <2 x double> poison, double %2, i64 0
%193 = shufflevector <2 x double> %192, <2 x double> poison, <2 x i32> zeroinitializer
br label %194
194: ; preds = %194, %190
%195 = phi i64 [ 0, %190 ], [ %217, %194 ]
%196 = getelementptr inbounds double, double* %9, i64 %195
%197 = bitcast double* %196 to <2 x double>*
%198 = load <2 x double>, <2 x double>* %197
%199 = fmul <2 x double> %198, %193
%200 = getelementptr inbounds double, double* %187, i64 %195
%201 = bitcast double* %200 to <2 x double>*
store <2 x double> %199, <2 x double>* %201
%202 = getelementptr inbounds double, double* %3, i64 %195
%203 = bitcast double* %202 to <2 x double>*
%204 = load <2 x double>, <2 x double>* %203
%205 = getelementptr inbounds double, double* %11, i64 %195
%206 = bitcast double* %205 to <2 x double>*
%207 = load <2 x double>, <2 x double>* %206
%208 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %207, <2 x double> <double 3.000000e-01, double 3.000000e-01>, <2 x double> %204)
%209 = getelementptr inbounds double, double* %188, i64 %195
%210 = bitcast double* %209 to <2 x double>*
%211 = load <2 x double>, <2 x double>* %210
%212 = fneg <2 x double> %211
%213 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %212, <2 x double> <double 9.000000e-01, double 9.000000e-01>, <2 x double> %208)
%214 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %199, <2 x double> <double 1.200000e+00, double 1.200000e+00>, <2 x double> %213)
%215 = getelementptr inbounds double, double* %8, i64 %195
%216 = bitcast double* %215 to <2 x double>*
store <2 x double> %214, <2 x double>* %216
%217 = add nuw i64 %195, 2
%218 = icmp eq i64 %217, %191
br i1 %218, label %219, label %194
219: ; preds = %194
%220 = icmp eq i64 %191, %7
br i1 %220, label %243, label %221
221: ; preds = %185, %219
%222 = phi i64 [ 0, %185 ], [ %191, %219 ]
br label %223
223: ; preds = %221, %223
%224 = phi i64 [ %240, %223 ], [ %222, %221 ]
%225 = getelementptr inbounds double, double* %9, i64 %224
%226 = load double, double* %225
%227 = fmul double %226, %2
%228 = getelementptr inbounds double, double* %187, i64 %224
store double %227, double* %228
%229 = getelementptr inbounds double, double* %3, i64 %224
%230 = load double, double* %229
%231 = getelementptr inbounds double, double* %11, i64 %224
%232 = load double, double* %231
%233 = call double @llvm.fmuladd.f64(double %232, double 3.000000e-01, double %230)
%234 = getelementptr inbounds double, double* %188, i64 %224
%235 = load double, double* %234
%236 = fneg double %235
%237 = call double @llvm.fmuladd.f64(double %236, double 9.000000e-01, double %233)
%238 = call double @llvm.fmuladd.f64(double %227, double 1.200000e+00, double %237)
%239 = getelementptr inbounds double, double* %8, i64 %224
store double %238, double* %239
%240 = add nuw nsw i64 %224, 1
%241 = icmp eq i64 %240, %7
br i1 %241, label %243, label %223
242: ; preds = %183, %184
br label %310
243: ; preds = %223, %219
br i1 %12, label %244, label %310
244: ; preds = %243
%245 = mul nuw nsw i64 %7, 3
%246 = getelementptr inbounds double, double* %11, i64 %245
%247 = getelementptr inbounds double, double* %11, i64 %7
%248 = shl nuw nsw i64 %7, 1
%249 = getelementptr inbounds double, double* %11, i64 %248
%250 = icmp eq i32 %1, 1
br i1 %250, label %286, label %251
251: ; preds = %244
%252 = and i64 %7, 4294967294
%253 = insertelement <2 x double> poison, double %2, i64 0
%254 = shufflevector <2 x double> %253, <2 x double> poison, <2 x i32> zeroinitializer
br label %255
255: ; preds = %255, %251
%256 = phi i64 [ 0, %251 ], [ %282, %255 ]
%257 = getelementptr inbounds double, double* %9, i64 %256
%258 = bitcast double* %257 to <2 x double>*
%259 = load <2 x double>, <2 x double>* %258
%260 = fmul <2 x double> %259, %254
%261 = getelementptr inbounds double, double* %246, i64 %256
%262 = bitcast double* %261 to <2 x double>*
store <2 x double> %260, <2 x double>* %262
%263 = getelementptr inbounds double, double* %3, i64 %256
%264 = bitcast double* %263 to <2 x double>*
%265 = load <2 x double>, <2 x double>* %264
%266 = getelementptr inbounds double, double* %11, i64 %256
%267 = bitcast double* %266 to <2 x double>*
%268 = load <2 x double>, <2 x double>* %267
%269 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %268, <2 x double> <double 0x3FB3333333333333, double 0x3FB3333333333333>, <2 x double> %265)
%270 = getelementptr inbounds double, double* %247, i64 %256
%271 = bitcast double* %270 to <2 x double>*
%272 = load <2 x double>, <2 x double>* %271
%273 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %272, <2 x double> <double 6.750000e-01, double 6.750000e-01>, <2 x double> %269)
%274 = getelementptr inbounds double, double* %249, i64 %256
%275 = bitcast double* %274 to <2 x double>*
%276 = load <2 x double>, <2 x double>* %275
%277 = fneg <2 x double> %276
%278 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %277, <2 x double> <double 6.000000e-01, double 6.000000e-01>, <2 x double> %273)
%279 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %276, <2 x double> <double 7.500000e-01, double 7.500000e-01>, <2 x double> %278)
%280 = getelementptr inbounds double, double* %8, i64 %256
%281 = bitcast double* %280 to <2 x double>*
store <2 x double> %279, <2 x double>* %281
%282 = add nuw i64 %256, 2
%283 = icmp eq i64 %282, %252
br i1 %283, label %284, label %255
284: ; preds = %255
%285 = icmp eq i64 %252, %7
br i1 %285, label %311, label %286
286: ; preds = %244, %284
%287 = phi i64 [ 0, %244 ], [ %252, %284 ]
br label %288
288: ; preds = %286, %288
%289 = phi i64 [ %308, %288 ], [ %287, %286 ]
%290 = getelementptr inbounds double, double* %9, i64 %289
%291 = load double, double* %290
%292 = fmul double %291, %2
%293 = getelementptr inbounds double, double* %246, i64 %289
store double %292, double* %293
%294 = getelementptr inbounds double, double* %3, i64 %289
%295 = load double, double* %294
%296 = getelementptr inbounds double, double* %11, i64 %289
%297 = load double, double* %296
%298 = call double @llvm.fmuladd.f64(double %297, double 0x3FB3333333333333, double %295)
%299 = getelementptr inbounds double, double* %247, i64 %289
%300 = load double, double* %299
%301 = call double @llvm.fmuladd.f64(double %300, double 6.750000e-01, double %298)
%302 = getelementptr inbounds double, double* %249, i64 %289
%303 = load double, double* %302
%304 = fneg double %303
%305 = call double @llvm.fmuladd.f64(double %304, double 6.000000e-01, double %301)
%306 = call double @llvm.fmuladd.f64(double %303, double 7.500000e-01, double %305)
%307 = getelementptr inbounds double, double* %8, i64 %289
store double %306, double* %307
%308 = add nuw nsw i64 %289, 1
%309 = icmp eq i64 %308, %7
br i1 %309, label %311, label %288
310: ; preds = %242, %243
br label %389
311: ; preds = %288, %284
br i1 %12, label %312, label %389
312: ; preds = %311
%313 = shl nuw nsw i64 %7, 2
%314 = getelementptr inbounds double, double* %11, i64 %313
%315 = getelementptr inbounds double, double* %11, i64 %7
%316 = shl nuw nsw i64 %7, 1
%317 = getelementptr inbounds double, double* %11, i64 %316
%318 = mul nuw nsw i64 %7, 3
%319 = getelementptr inbounds double, double* %11, i64 %318
%320 = icmp eq i32 %1, 1
br i1 %320, label %361, label %321
321: ; preds = %312
%322 = and i64 %7, 4294967294
%323 = insertelement <2 x double> poison, double %2, i64 0
%324 = shufflevector <2 x double> %323, <2 x double> poison, <2 x i32> zeroinitializer
br label %325
325: ; preds = %325, %321
%326 = phi i64 [ 0, %321 ], [ %357, %325 ]
%327 = getelementptr inbounds double, double* %9, i64 %326
%328 = bitcast double* %327 to <2 x double>*
%329 = load <2 x double>, <2 x double>* %328
%330 = fmul <2 x double> %329, %324
%331 = getelementptr inbounds double, double* %314, i64 %326
%332 = bitcast double* %331 to <2 x double>*
store <2 x double> %330, <2 x double>* %332
%333 = getelementptr inbounds double, double* %3, i64 %326
%334 = bitcast double* %333 to <2 x double>*
%335 = load <2 x double>, <2 x double>* %334
%336 = getelementptr inbounds double, double* %11, i64 %326
%337 = bitcast double* %336 to <2 x double>*
%338 = load <2 x double>, <2 x double>* %337
%339 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %338, <2 x double> <double 0x3FE522C3F35BA77A, double 0x3FE522C3F35BA77A>, <2 x double> %335)
%340 = getelementptr inbounds double, double* %315, i64 %326
%341 = bitcast double* %340 to <2 x double>*
%342 = load <2 x double>, <2 x double>* %341
%343 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %342, <2 x double> <double 2.500000e+00, double 2.500000e+00>, <2 x double> %339)
%344 = getelementptr inbounds double, double* %317, i64 %326
%345 = bitcast double* %344 to <2 x double>*
%346 = load <2 x double>, <2 x double>* %345
%347 = fneg <2 x double> %346
%348 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %347, <2 x double> <double 0x4014BDA12F684BDA, double 0x4014BDA12F684BDA>, <2 x double> %343)
%349 = getelementptr inbounds double, double* %319, i64 %326
%350 = bitcast double* %349 to <2 x double>*
%351 = load <2 x double>, <2 x double>* %350
%352 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %351, <2 x double> <double 0x400F1C71C71C71C7, double 0x400F1C71C71C71C7>, <2 x double> %348)
%353 = fneg <2 x double> %330
%354 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %353, <2 x double> <double 0x3FEBA781948B0FC9, double 0x3FEBA781948B0FC9>, <2 x double> %352)
%355 = getelementptr inbounds double, double* %8, i64 %326
%356 = bitcast double* %355 to <2 x double>*
store <2 x double> %354, <2 x double>* %356
%357 = add nuw i64 %326, 2
%358 = icmp eq i64 %357, %322
br i1 %358, label %359, label %325
359: ; preds = %325
%360 = icmp eq i64 %322, %7
br i1 %360, label %390, label %361
361: ; preds = %312, %359
%362 = phi i64 [ 0, %312 ], [ %322, %359 ]
br label %363
363: ; preds = %361, %363
%364 = phi i64 [ %387, %363 ], [ %362, %361 ]
%365 = getelementptr inbounds double, double* %9, i64 %364
%366 = load double, double* %365
%367 = fmul double %366, %2
%368 = getelementptr inbounds double, double* %314, i64 %364
store double %367, double* %368
%369 = getelementptr inbounds double, double* %3, i64 %364
%370 = load double, double* %369
%371 = getelementptr inbounds double, double* %11, i64 %364
%372 = load double, double* %371
%373 = call double @llvm.fmuladd.f64(double %372, double 0x3FE522C3F35BA77A, double %370)
%374 = getelementptr inbounds double, double* %315, i64 %364
%375 = load double, double* %374
%376 = call double @llvm.fmuladd.f64(double %375, double 2.500000e+00, double %373)
%377 = getelementptr inbounds double, double* %317, i64 %364
%378 = load double, double* %377
%379 = fneg double %378
%380 = call double @llvm.fmuladd.f64(double %379, double 0x4014BDA12F684BDA, double %376)
%381 = getelementptr inbounds double, double* %319, i64 %364
%382 = load double, double* %381
%383 = call double @llvm.fmuladd.f64(double %382, double 0x400F1C71C71C71C7, double %380)
%384 = fneg double %367
%385 = call double @llvm.fmuladd.f64(double %384, double 0x3FEBA781948B0FC9, double %383)
%386 = getelementptr inbounds double, double* %8, i64 %364
store double %385, double* %386
%387 = add nuw nsw i64 %364, 1
%388 = icmp eq i64 %387, %7
br i1 %388, label %390, label %363
389: ; preds = %310, %311
br label %533
390: ; preds = %363, %359
br i1 %12, label %391, label %533
391: ; preds = %390
%392 = mul nuw nsw i64 %7, 5
%393 = getelementptr inbounds double, double* %11, i64 %392
%394 = shl nuw nsw i64 %7, 1
%395 = getelementptr inbounds double, double* %11, i64 %394
%396 = mul nuw nsw i64 %7, 3
%397 = getelementptr inbounds double, double* %11, i64 %396
%398 = shl nuw nsw i64 %7, 2
%399 = getelementptr inbounds double, double* %11, i64 %398
%400 = icmp eq i32 %1, 1
br i1 %400, label %438, label %401
401: ; preds = %391
%402 = and i64 %7, 4294967294
%403 = insertelement <2 x double> poison, double %2, i64 0
%404 = shufflevector <2 x double> %403, <2 x double> poison, <2 x i32> zeroinitializer
br label %405
405: ; preds = %405, %401
%406 = phi i64 [ 0, %401 ], [ %434, %405 ]
%407 = getelementptr inbounds double, double* %9, i64 %406
%408 = bitcast double* %407 to <2 x double>*
%409 = load <2 x double>, <2 x double>* %408
%410 = fmul <2 x double> %409, %404
%411 = getelementptr inbounds double, double* %393, i64 %406
%412 = bitcast double* %411 to <2 x double>*
store <2 x double> %410, <2 x double>* %412
%413 = getelementptr inbounds double, double* %3, i64 %406
%414 = bitcast double* %413 to <2 x double>*
%415 = load <2 x double>, <2 x double>* %414
%416 = getelementptr inbounds double, double* %11, i64 %406
%417 = bitcast double* %416 to <2 x double>*
%418 = load <2 x double>, <2 x double>* %417
%419 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %418, <2 x double> <double 0x3FBADD3C0CA45879, double 0x3FBADD3C0CA45879>, <2 x double> %415)
%420 = getelementptr inbounds double, double* %395, i64 %406
%421 = bitcast double* %420 to <2 x double>*
%422 = load <2 x double>, <2 x double>* %421
%423 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %422, <2 x double> <double 0x3FD7B425ED097B41, double 0x3FD7B425ED097B41>, <2 x double> %419)
%424 = getelementptr inbounds double, double* %397, i64 %406
%425 = bitcast double* %424 to <2 x double>*
%426 = load <2 x double>, <2 x double>* %425
%427 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %426, <2 x double> <double 0x3FD1C71C71C71C70, double 0x3FD1C71C71C71C70>, <2 x double> %423)
%428 = getelementptr inbounds double, double* %399, i64 %406
%429 = bitcast double* %428 to <2 x double>*
%430 = load <2 x double>, <2 x double>* %429
%431 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %430, <2 x double> <double 0x3FCF9ADD3C0CA456, double 0x3FCF9ADD3C0CA456>, <2 x double> %427)
%432 = getelementptr inbounds double, double* %8, i64 %406
%433 = bitcast double* %432 to <2 x double>*
store <2 x double> %431, <2 x double>* %433
%434 = add nuw i64 %406, 2
%435 = icmp eq i64 %434, %402
br i1 %435, label %436, label %405
436: ; preds = %405
%437 = icmp eq i64 %402, %7
br i1 %437, label %440, label %438
438: ; preds = %391, %436
%439 = phi i64 [ 0, %391 ], [ %402, %436 ]
br label %487
440: ; preds = %487, %436
br i1 %12, label %441, label %533
441: ; preds = %440
%442 = shl nuw nsw i64 %7, 1
%443 = getelementptr inbounds double, double* %11, i64 %442
%444 = mul nuw nsw i64 %7, 3
%445 = getelementptr inbounds double, double* %11, i64 %444
%446 = shl nuw nsw i64 %7, 2
%447 = getelementptr inbounds double, double* %11, i64 %446
%448 = mul nuw nsw i64 %7, 5
%449 = getelementptr inbounds double, double* %11, i64 %448
%450 = icmp eq i32 %1, 1
br i1 %450, label %485, label %451
451: ; preds = %441
%452 = and i64 %7, 4294967294
br label %453
453: ; preds = %453, %451
%454 = phi i64 [ 0, %451 ], [ %481, %453 ]
%455 = getelementptr inbounds double, double* %11, i64 %454
%456 = bitcast double* %455 to <2 x double>*
%457 = load <2 x double>, <2 x double>* %456
%458 = getelementptr inbounds double, double* %443, i64 %454
%459 = bitcast double* %458 to <2 x double>*
%460 = load <2 x double>, <2 x double>* %459
%461 = fmul <2 x double> %460, <double 0x3FD965965965964B, double 0x3FD965965965964B>
%462 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %457, <2 x double> <double 0x3FB948B0FCD6E9C1, double 0x3FB948B0FCD6E9C1>, <2 x double> %461)
%463 = getelementptr inbounds double, double* %445, i64 %454
%464 = bitcast double* %463 to <2 x double>*
%465 = load <2 x double>, <2 x double>* %464
%466 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %465, <2 x double> <double 0x3FCDA12F684BDA02, double 0x3FCDA12F684BDA02>, <2 x double> %462)
%467 = getelementptr inbounds double, double* %447, i64 %454
%468 = bitcast double* %467 to <2 x double>*
%469 = load <2 x double>, <2 x double>* %468
%470 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %469, <2 x double> <double 0x3FD3C0CA4587E6A6, double 0x3FD3C0CA4587E6A6>, <2 x double> %466)
%471 = getelementptr inbounds double, double* %449, i64 %454
%472 = bitcast double* %471 to <2 x double>*
%473 = load <2 x double>, <2 x double>* %472
%474 = fneg <2 x double> %473
%475 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %474, <2 x double> <double 0x3FA249249249242B, double 0x3FA249249249242B>, <2 x double> %470)
%476 = getelementptr inbounds double, double* %3, i64 %454
%477 = bitcast double* %476 to <2 x double>*
%478 = load <2 x double>, <2 x double>* %477
%479 = fadd <2 x double> %478, %475
%480 = bitcast double* %476 to <2 x double>*
store <2 x double> %479, <2 x double>* %480
%481 = add nuw i64 %454, 2
%482 = icmp eq i64 %481, %452
br i1 %482, label %483, label %453
483: ; preds = %453
%484 = icmp eq i64 %452, %7
br i1 %484, label %533, label %485
485: ; preds = %441, %483
%486 = phi i64 [ 0, %441 ], [ %452, %483 ]
br label %510
487: ; preds = %438, %487
%488 = phi i64 [ %508, %487 ], [ %439, %438 ]
%489 = getelementptr inbounds double, double* %9, i64 %488
%490 = load double, double* %489
%491 = fmul double %490, %2
%492 = getelementptr inbounds double, double* %393, i64 %488
store double %491, double* %492
%493 = getelementptr inbounds double, double* %3, i64 %488
%494 = load double, double* %493
%495 = getelementptr inbounds double, double* %11, i64 %488
%496 = load double, double* %495
%497 = call double @llvm.fmuladd.f64(double %496, double 0x3FBADD3C0CA45879, double %494)
%498 = getelementptr inbounds double, double* %395, i64 %488
%499 = load double, double* %498
%500 = call double @llvm.fmuladd.f64(double %499, double 0x3FD7B425ED097B41, double %497)
%501 = getelementptr inbounds double, double* %397, i64 %488
%502 = load double, double* %501
%503 = call double @llvm.fmuladd.f64(double %502, double 0x3FD1C71C71C71C70, double %500)
%504 = getelementptr inbounds double, double* %399, i64 %488
%505 = load double, double* %504
%506 = call double @llvm.fmuladd.f64(double %505, double 0x3FCF9ADD3C0CA456, double %503)
%507 = getelementptr inbounds double, double* %8, i64 %488
store double %506, double* %507
%508 = add nuw nsw i64 %488, 1
%509 = icmp eq i64 %508, %7
br i1 %509, label %440, label %487
510: ; preds = %485, %510
%511 = phi i64 [ %531, %510 ], [ %486, %485 ]
%512 = getelementptr inbounds double, double* %11, i64 %511
%513 = load double, double* %512
%514 = getelementptr inbounds double, double* %443, i64 %511
%515 = load double, double* %514
%516 = fmul double %515, 0x3FD965965965964B
%517 = call double @llvm.fmuladd.f64(double %513, double 0x3FB948B0FCD6E9C1, double %516)
%518 = getelementptr inbounds double, double* %445, i64 %511
%519 = load double, double* %518
%520 = call double @llvm.fmuladd.f64(double %519, double 0x3FCDA12F684BDA02, double %517)
%521 = getelementptr inbounds double, double* %447, i64 %511
%522 = load double, double* %521
%523 = call double @llvm.fmuladd.f64(double %522, double 0x3FD3C0CA4587E6A6, double %520)
%524 = getelementptr inbounds double, double* %449, i64 %511
%525 = load double, double* %524
%526 = fneg double %525
%527 = call double @llvm.fmuladd.f64(double %526, double 0x3FA249249249242B, double %523)
%528 = getelementptr inbounds double, double* %3, i64 %511
%529 = load double, double* %528
%530 = fadd double %529, %527
store double %530, double* %528
%531 = add nuw nsw i64 %511, 1
%532 = icmp eq i64 %531, %7
br i1 %532, label %533, label %510
533: ; preds = %510, %483, %390, %389, %440
ret void
}