void rungeKutta(void (*f)(double, double *, double *, double *), double *r,
                double *initial, int initial_length, double stopTime,
                double stepSize, int density, double **ret, int ret_length) {
  double h = ((double)stepSize) / ((double)density);
  double x = 0;
  int n = initial_length;
  double *y = initial;
  double k1[n];
  double k2[n];
  double k3[n];
  double k4[n];
  double tmp[n];
  int p = 0;
  while (x < stopTime) {
    if (!(p % density) && p / density < ret_length) {
      for (int i = 0; i < n; ++i) {
        ret[p / density][i] = y[i];
      }
    }
    ++p;
    f(x, y, r, k1);
    for (int i = 0; i < n; ++i) {
      tmp[i] = y[i] + h * k1[i] / 2;
    }
    f(x + h / 2, tmp, r, k2);
    for (int i = 0; i < n; ++i) {
      tmp[i] = y[i] + h * k2[i] / 2;
    }
    f(x + h / 2, tmp, r, k3);
    for (int i = 0; i < n; ++i) {
      tmp[i] = y[i] + h * k3[i];
    }
    f(x + h, tmp, r, k4);
    for (int i = 0; i < n; ++i) {
      y[i] += h / 6 * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i]);
    }
    x += h;
  }
}


x86 assembly (clang, -O0):
<rungeKutta>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
mov    %r8d,-0x34(%rbp)
mov    %r9,-0x40(%rbp)
movsd  -0x30(%rbp),%xmm0
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x68(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x70(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xc8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x78(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xc0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x80(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xb8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x88(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xb0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x94(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    15a5 <rungeKutta+0x4a5>
mov    -0x94(%rbp),%eax
cltd
idivl  -0x34(%rbp)
cmp    $0x0,%edx
jne    12cb <rungeKutta+0x1cb>
mov    -0x94(%rbp),%eax
cltd
idivl  -0x34(%rbp)
cmp    0x10(%rbp),%eax
jge    12cb <rungeKutta+0x1cb>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    12c6 <rungeKutta+0x1c6>
mov    -0x60(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x94(%rbp),%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,%ecx
mov    -0xd8(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1262 <rungeKutta+0x162>
jmp    12cb <rungeKutta+0x1cb>
mov    -0xd0(%rbp),%rdx
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0x8(%rbp),%rax
movsd  -0x50(%rbp),%xmm0
mov    -0x60(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   *%rax
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    136c <rungeKutta+0x26c>
mov    -0xb0(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movslq -0x9c(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  -0x48(%rbp),%xmm1
movslq -0x9c(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm1
movsd  0xcbc(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    12fe <rungeKutta+0x1fe>
mov    -0xc8(%rbp),%rdx
mov    -0xb0(%rbp),%rdi
mov    -0x8(%rbp),%rax
movsd  -0x50(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  0xc70(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rsi
call   *%rax
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1416 <rungeKutta+0x316>
mov    -0xb0(%rbp),%rax
mov    -0xc8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movslq -0xa0(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  -0x48(%rbp),%xmm1
movslq -0xa0(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm1
movsd  0xc12(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movslq -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    13a8 <rungeKutta+0x2a8>
mov    -0xc0(%rbp),%rdx
mov    -0xb0(%rbp),%rdi
mov    -0x8(%rbp),%rax
movsd  -0x50(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  0xbc6(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rsi
call   *%rax
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    14b8 <rungeKutta+0x3b8>
mov    -0xb0(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movslq -0xa4(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm1
movsd  -0x48(%rbp),%xmm0
movslq -0xa4(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1452 <rungeKutta+0x352>
mov    -0xb8(%rbp),%rdx
mov    -0xb0(%rbp),%rdi
mov    -0x8(%rbp),%rax
movsd  -0x50(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rsi
call   *%rax
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1591 <rungeKutta+0x491>
mov    -0xb8(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    -0xc8(%rbp),%rdx
mov    -0xd0(%rbp),%rsi
movsd  -0x48(%rbp),%xmm0
movsd  0xaec(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0xa8(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm2
movslq -0xa8(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movslq -0xa8(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movslq -0xa8(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mov    -0x60(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    14e4 <rungeKutta+0x3e4>
movsd  -0x48(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    121e <rungeKutta+0x11e>
mov    -0x68(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rungeKutta>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r9,-0x118(%rbp)
mov    %r8d,-0x6c(%rbp)
mov    %ecx,%r8d
mov    %ecx,%r14d
mov    %rsp,%r15
lea    0xf(,%r14,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    %rsp,%r13
sub    %rax,%r13
mov    %r13,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,%rsp
mov    %rsp,%r10
sub    %rax,%r10
mov    %r10,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
xorpd  %xmm3,%xmm3
movsd  %xmm0,-0x120(%rbp)
ff
ucomisd %xmm3,%xmm0
jbe    1ac8 <rungeKutta+0x9c8>
mov    %rdx,%rbx
mov    %rdi,%r9
xorps  %xmm0,%xmm0
cvtsi2sdl -0x6c(%rbp),%xmm0
divsd  %xmm0,%xmm1
movsd  0xe72(%rip),%xmm0
movapd %xmm1,%xmm4
divsd  0xe6e(%rip),%xmm4
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
lea    (%rdx,%r14,8),%rax
mov    %rax,-0x108(%rbp)
mov    %r14d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x80(%rbp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x78(%rbp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r11d
and    $0x3,%r11d
mov    %rdx,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,-0xe8(%rbp)
mov    %r14d,%eax
and    $0x3,%eax
mov    %rax,-0x110(%rbp)
movapd %xmm1,%xmm5
unpcklpd %xmm1,%xmm5
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
mov    %rdx,%rax
mov    %rdx,-0xa0(%rbp)
and    %rdx,%rdi
mov    %rdi,-0x98(%rbp)
mov    %r14d,%edx
and    $0xfffffffe,%edx
movapd %xmm4,%xmm6
unpcklpd %xmm4,%xmm6
lea    0x10(%rbx),%rax
mov    %rax,-0xf0(%rbp)
mov    %r11,-0xf8(%rbp)
shl    $0x5,%r11
xor    %eax,%eax
movapd %xmm1,-0xc0(%rbp)
ff
mov    %r8d,-0x2c(%rbp)
mov    %rsi,-0x48(%rbp)
mov    %r9,-0x40(%rbp)
mov    %r14,-0x58(%rbp)
mov    %r13,-0x60(%rbp)
mov    %rcx,-0x50(%rbp)
mov    %r10,-0xa8(%rbp)
movapd %xmm4,-0x140(%rbp)
ff
movapd %xmm5,-0xe0(%rbp)
ff
mov    %rdx,-0x100(%rbp)
movapd %xmm6,-0x130(%rbp)
ff
mov    %r11,-0x88(%rbp)
jmp    132c <rungeKutta+0x22c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    %r12,%rdi
mov    %r13,%rsi
mov    -0x60(%rbp),%rdx
call   *%r14
movsd  -0x68(%rbp),%xmm0
mov    -0x50(%rbp),%rdx
mov    %r12,%rdi
mov    %r13,%rsi
call   *%r14
movapd -0xc0(%rbp),%xmm3
ff
mov    -0xa8(%rbp),%rdx
movsd  -0x38(%rbp),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    %r12,%rdi
mov    %r13,%rsi
call   *%r14
movsd  -0x38(%rbp),%xmm3
mov    -0x2c(%rbp),%r8d
mov    %r13,%rsi
mov    %r14,%r9
mov    -0x58(%rbp),%r14
mov    -0x88(%rbp),%r11
mov    -0x90(%rbp),%rax
add    $0x1,%eax
movsd  -0x120(%rbp),%xmm0
ff
ucomisd %xmm3,%xmm0
jbe    1ac8 <rungeKutta+0x9c8>
mov    %rax,-0x90(%rbp)
cltd
idivl  -0x6c(%rbp)
test   %edx,%edx
jne    14b0 <rungeKutta+0x3b0>
cmp    0x10(%rbp),%eax
jge    14b0 <rungeKutta+0x3b0>
test   %r8d,%r8d
jle    14b0 <rungeKutta+0x3b0>
cltq
mov    -0x118(%rbp),%rcx
mov    (%rcx,%rax,8),%rax
cmp    $0x4,%r8d
jb     1376 <rungeKutta+0x276>
cmp    -0x108(%rbp),%rax
jae    13ec <rungeKutta+0x2ec>
lea    (%rax,%r14,8),%rcx
cmp    %rbx,%rcx
jbe    13ec <rungeKutta+0x2ec>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r14,%rdx
mov    -0x110(%rbp),%rdi
test   %rdi,%rdi
je     13a4 <rungeKutta+0x2a4>
nopl   (%rax)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1390 <rungeKutta+0x290>
cmp    $0x3,%rdx
jb     14b0 <rungeKutta+0x3b0>
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r14
jne    13b0 <rungeKutta+0x2b0>
jmp    14b0 <rungeKutta+0x3b0>
cmpq   $0xc,-0x78(%rbp)
jae    13f7 <rungeKutta+0x2f7>
xor    %ecx,%ecx
jmp    145c <rungeKutta+0x35c>
mov    -0xe8(%rbp),%rdx
xor    %ecx,%ecx
movups (%rbx,%rcx,8),%xmm0
movups 0x10(%rbx,%rcx,8),%xmm2
movups %xmm0,(%rax,%rcx,8)
movups %xmm2,0x10(%rax,%rcx,8)
movups 0x20(%rbx,%rcx,8),%xmm0
movups 0x30(%rbx,%rcx,8),%xmm2
movups %xmm0,0x20(%rax,%rcx,8)
movups %xmm2,0x30(%rax,%rcx,8)
movups 0x40(%rbx,%rcx,8),%xmm0
movups 0x50(%rbx,%rcx,8),%xmm2
movups %xmm0,0x40(%rax,%rcx,8)
movups %xmm2,0x50(%rax,%rcx,8)
movupd 0x60(%rbx,%rcx,8),%xmm0
movupd 0x70(%rbx,%rcx,8),%xmm2
movupd %xmm0,0x60(%rax,%rcx,8)
movupd %xmm2,0x70(%rax,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    1400 <rungeKutta+0x300>
cmpq   $0x0,-0xf8(%rbp)
je     149f <rungeKutta+0x39f>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    -0xf0(%rbp),%rdi
lea    (%rdi,%rcx,8),%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rdi,1),%xmm0
movupd (%rcx,%rdi,1),%xmm2
movupd %xmm0,-0x10(%rdx,%rdi,1)
movupd %xmm2,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r11
jne    1480 <rungeKutta+0x380>
mov    -0x80(%rbp),%rdx
mov    %rdx,%rcx
cmp    %r14,%rdx
jne    1378 <rungeKutta+0x278>
nop
movapd %xmm3,%xmm0
mov    %rbx,%rdi
mov    %r15,%rdx
mov    %rsi,%r13
mov    %r9,%r14
movsd  %xmm3,-0x38(%rbp)
call   *%r9
movsd  -0x38(%rbp),%xmm1
mov    -0x2c(%rbp),%eax
test   %eax,%eax
jle    12a0 <rungeKutta+0x1a0>
cmp    $0x4,%eax
movapd -0xc0(%rbp),%xmm4
ff
jae    1510 <rungeKutta+0x410>
xor    %eax,%eax
mov    -0x48(%rbp),%rsi
mov    -0x40(%rbp),%r8
mov    -0x58(%rbp),%r14
mov    -0x60(%rbp),%r13
movsd  -0x38(%rbp),%xmm5
movsd  0xafc(%rip),%xmm1
jmp    1640 <rungeKutta+0x540>
nopl   0x0(%rax)
cmpq   $0x0,-0x78(%rbp)
movapd -0xe0(%rbp),%xmm6
ff
movapd 0xaeb(%rip),%xmm7
je     177e <rungeKutta+0x67e>
mov    -0x98(%rbp),%rcx
xor    %eax,%eax
mov    -0x48(%rbp),%rsi
mov    -0x40(%rbp),%r8
mov    -0x58(%rbp),%r14
mov    -0x60(%rbp),%r13
movsd  -0x38(%rbp),%xmm5
nopl   0x0(%rax)
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movapd (%r15,%rax,8),%xmm2
mulpd  %xmm6,%xmm2
movapd 0x10(%r15,%rax,8),%xmm3
mulpd  %xmm6,%xmm3
mulpd  %xmm7,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm2,(%r12,%rax,8)
movapd %xmm3,0x10(%r12,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm0
movupd 0x30(%rbx,%rax,8),%xmm1
movapd 0x20(%r15,%rax,8),%xmm2
mulpd  %xmm6,%xmm2
movapd 0x30(%r15,%rax,8),%xmm3
mulpd  %xmm6,%xmm3
mulpd  %xmm7,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm2,0x20(%r12,%rax,8)
movapd %xmm3,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1550 <rungeKutta+0x450>
testb  $0x1,-0xa0(%rbp)
je     1621 <rungeKutta+0x521>
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movapd (%r15,%rax,8),%xmm2
mulpd  %xmm6,%xmm2
movapd 0x10(%r15,%rax,8),%xmm3
mulpd  %xmm6,%xmm3
mulpd  %xmm7,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm2,(%r12,%rax,8)
movapd %xmm3,0x10(%r12,%rax,8)
mov    -0x80(%rbp),%rcx
mov    %rcx,%rax
cmp    %r14,%rcx
movsd  0x9cd(%rip),%xmm1
je     1662 <rungeKutta+0x562>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm1,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1640 <rungeKutta+0x540>
movsd  -0xc8(%rbp),%xmm0
ff
addsd  %xmm5,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    %r12,%rdi
mov    %r13,%rdx
call   *%r8
mov    -0x2c(%rbp),%eax
test   %eax,%eax
jle    16b0 <rungeKutta+0x5b0>
cmp    $0x4,%eax
jae    16c6 <rungeKutta+0x5c6>
xor    %eax,%eax
movapd -0xc0(%rbp),%xmm4
ff
mov    -0x48(%rbp),%rsi
mov    -0x40(%rbp),%rcx
mov    -0x50(%rbp),%rdx
movsd  0x95a(%rip),%xmm1
movsd  -0x68(%rbp),%xmm0
jmp    1820 <rungeKutta+0x720>
mov    -0x48(%rbp),%r13
mov    -0x40(%rbp),%r14
mov    -0x50(%rbp),%rdx
movsd  -0x68(%rbp),%xmm0
jmp    12c7 <rungeKutta+0x1c7>
cmpq   $0x0,-0x78(%rbp)
movapd -0xe0(%rbp),%xmm5
ff
movapd 0x935(%rip),%xmm6
je     17a7 <rungeKutta+0x6a7>
mov    -0x98(%rbp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movapd 0x0(%r13,%rax,8),%xmm2
mulpd  %xmm5,%xmm2
movapd 0x10(%r13,%rax,8),%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm6,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm6,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm2,(%r12,%rax,8)
movapd %xmm3,0x10(%r12,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm0
movupd 0x30(%rbx,%rax,8),%xmm1
movapd 0x20(%r13,%rax,8),%xmm2
mulpd  %xmm5,%xmm2
movapd 0x30(%r13,%rax,8),%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm6,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm6,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm2,0x20(%r12,%rax,8)
movapd %xmm3,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    16f0 <rungeKutta+0x5f0>
jmp    17a9 <rungeKutta+0x6a9>
xor    %eax,%eax
mov    -0x48(%rbp),%rsi
mov    -0x40(%rbp),%r8
mov    -0x58(%rbp),%r14
mov    -0x60(%rbp),%r13
movsd  -0x38(%rbp),%xmm5
testb  $0x1,-0xa0(%rbp)
jne    15e4 <rungeKutta+0x4e4>
jmp    1621 <rungeKutta+0x521>
xor    %eax,%eax
testb  $0x1,-0xa0(%rbp)
movapd -0xc0(%rbp),%xmm4
ff
mov    -0x48(%rbp),%rsi
mov    -0x40(%rbp),%rcx
mov    -0x50(%rbp),%rdx
je     1804 <rungeKutta+0x704>
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movapd 0x0(%r13,%rax,8),%xmm2
mulpd  %xmm5,%xmm2
movapd 0x10(%r13,%rax,8),%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm6,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm6,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm2,(%r12,%rax,8)
movapd %xmm3,0x10(%r12,%rax,8)
mov    -0x80(%rbp),%rdi
mov    %rdi,%rax
cmp    %r14,%rdi
movsd  0x7ea(%rip),%xmm1
movsd  -0x68(%rbp),%xmm0
je     1843 <rungeKutta+0x743>
nopl   (%rax)
movsd  0x0(%r13,%rax,8),%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rbx,%rax,8),%xmm2
movsd  %xmm2,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1820 <rungeKutta+0x720>
mov    %r12,%rdi
mov    %rsi,%r13
mov    %rcx,%r14
call   *%rcx
movapd -0xc0(%rbp),%xmm3
ff
cmpl   $0x0,-0x2c(%rbp)
mov    -0xa8(%rbp),%rdx
movsd  -0x38(%rbp),%xmm0
jle    12e4 <rungeKutta+0x1e4>
cmpl   $0x4,-0x2c(%rbp)
jae    188d <rungeKutta+0x78d>
xor    %eax,%eax
mov    -0x48(%rbp),%rsi
mov    -0x40(%rbp),%r8
mov    -0x58(%rbp),%r14
mov    -0x60(%rbp),%r13
mov    -0x50(%rbp),%rdi
jmp    1980 <rungeKutta+0x880>
cmpq   $0x0,-0x78(%rbp)
mov    -0x48(%rbp),%rsi
mov    -0x40(%rbp),%r8
mov    -0x60(%rbp),%r13
mov    -0x50(%rbp),%rdi
movapd -0xe0(%rbp),%xmm5
ff
je     1ab0 <rungeKutta+0x9b0>
mov    -0x98(%rbp),%rcx
xor    %eax,%eax
mov    -0x58(%rbp),%r14
nopl   (%rax)
movupd (%rbx,%rax,8),%xmm4
movupd 0x10(%rbx,%rax,8),%xmm1
movapd (%rdi,%rax,8),%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm4,%xmm2
movapd 0x10(%rdi,%rax,8),%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm2,(%r12,%rax,8)
movapd %xmm4,0x10(%r12,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm4
movupd 0x30(%rbx,%rax,8),%xmm1
movapd 0x20(%rdi,%rax,8),%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm4,%xmm2
movapd 0x30(%rdi,%rax,8),%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm2,0x20(%r12,%rax,8)
movapd %xmm4,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    18c0 <rungeKutta+0x7c0>
testb  $0x1,-0xa0(%rbp)
je     196f <rungeKutta+0x86f>
movupd (%rbx,%rax,8),%xmm4
movupd 0x10(%rbx,%rax,8),%xmm1
movapd (%rdi,%rax,8),%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm4,%xmm2
movapd 0x10(%rdi,%rax,8),%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm2,(%r12,%rax,8)
movapd %xmm4,0x10(%r12,%rax,8)
mov    -0x80(%rbp),%rcx
mov    %rcx,%rax
cmp    %r14,%rcx
je     199d <rungeKutta+0x89d>
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1980 <rungeKutta+0x880>
addsd  %xmm3,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    %r12,%rdi
call   *%r8
mov    -0x2c(%rbp),%r8d
test   %r8d,%r8d
jle    19f5 <rungeKutta+0x8f5>
cmp    $0x1,%r8d
mov    -0x48(%rbp),%rsi
mov    -0x40(%rbp),%r9
mov    -0x50(%rbp),%rcx
mov    -0xa8(%rbp),%r10
movsd  -0x38(%rbp),%xmm3
movapd -0x140(%rbp),%xmm4
ff
mov    -0x100(%rbp),%rdx
movapd -0x130(%rbp),%xmm6
ff
jne    1a07 <rungeKutta+0x907>
xor    %eax,%eax
mov    -0x88(%rbp),%r11
jmp    1a70 <rungeKutta+0x970>
mov    -0x48(%rbp),%rsi
mov    -0x40(%rbp),%r9
movsd  -0x38(%rbp),%xmm3
jmp    1309 <rungeKutta+0x209>
xor    %eax,%eax
nopl   0x0(%rax)
movapd 0x0(%r13,%rax,8),%xmm0
addpd  %xmm0,%xmm0
addpd  (%r15,%rax,8),%xmm0
movapd (%rcx,%rax,8),%xmm2
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  (%r10,%rax,8),%xmm2
mulpd  %xmm6,%xmm2
movupd (%rbx,%rax,8),%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1a10 <rungeKutta+0x910>
mov    %rdx,%rax
cmp    %r14,%rdx
mov    -0x88(%rbp),%r11
je     1310 <rungeKutta+0x210>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%r13,%rax,8),%xmm0
addsd  %xmm0,%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  (%rcx,%rax,8),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
addsd  (%r10,%rax,8),%xmm2
mulsd  %xmm4,%xmm2
addsd  (%rbx,%rax,8),%xmm2
movsd  %xmm2,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1a70 <rungeKutta+0x970>
jmp    1310 <rungeKutta+0x210>
xor    %eax,%eax
mov    -0x58(%rbp),%r14
testb  $0x1,-0xa0(%rbp)
jne    193c <rungeKutta+0x83c>
jmp    196f <rungeKutta+0x86f>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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