void rk4(double *y, double *dydx, int n, double x, double h, double *yout,
         int (*derivs)()) {
  double yt[10], dyt[10], dym[10];
  double hh, h6, xh;
  int i;
  hh = h * 0.5;
  h6 = h / 6.0;
  xh = x + hh;
  for (i = 0; i < n; i++)
    yt[i] = y[i] + hh * dydx[i];
  derivs(xh, yt, dyt);
  for (i = 0; i < n; i++)
    yt[i] = y[i] + hh * dyt[i];
  derivs(xh, yt, dym);
  for (i = 0; i < n; i++) {
    yt[i] = y[i] + h * dym[i];
    dym[i] = dyt[i] + dym[i];
  }
  derivs(x + h, yt, dyt);
  for (i = 0; i < n; i++)
    yout[i] = y[i] + h6 * (dydx[i] + dyt[i] + 2. * dym[i]);
}


x86 assembly (clang, -O0):
<rk4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
movsd  0xed8(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  0xeb6(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
addsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
movl   $0x0,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d8 <rk4+0xd8>
mov    -0x8(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x14c(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x14c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14c(%rbp)
jmp    1175 <rk4+0x75>
mov    -0x38(%rbp),%rcx
movsd  -0x148(%rbp),%xmm0
ff
lea    -0x90(%rbp),%rdi
lea    -0xe0(%rbp),%rsi
mov    $0x1,%al
call   *%rcx
movl   $0x0,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1263 <rk4+0x163>
mov    -0x8(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x138(%rbp),%xmm0
ff
movslq -0x14c(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x14c(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x14c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14c(%rbp)
jmp    1200 <rk4+0x100>
mov    -0x38(%rbp),%rcx
movsd  -0x148(%rbp),%xmm0
ff
lea    -0x90(%rbp),%rdi
lea    -0x130(%rbp),%rsi
mov    $0x1,%al
call   *%rcx
movl   $0x0,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    131b <rk4+0x21b>
mov    -0x8(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movslq -0x14c(%rbp),%rax
movsd  -0x130(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x14c(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
movslq -0x14c(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x14c(%rbp),%rax
addsd  -0x130(%rbp,%rax,8),%xmm0
ff ff
movslq -0x14c(%rbp),%rax
movsd  %xmm0,-0x130(%rbp,%rax,8)
ff ff
mov    -0x14c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14c(%rbp)
jmp    128b <rk4+0x18b>
mov    -0x38(%rbp),%rcx
movsd  -0x20(%rbp),%xmm0
addsd  -0x28(%rbp),%xmm0
lea    -0x90(%rbp),%rdi
lea    -0xe0(%rbp),%rsi
mov    $0x1,%al
call   *%rcx
movl   $0x0,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13d0 <rk4+0x2d0>
mov    -0x8(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movslq -0x14c(%rbp),%rax
addsd  -0xe0(%rbp,%rax,8),%xmm3
ff ff
movslq -0x14c(%rbp),%rax
movsd  -0x130(%rbp,%rax,8),%xmm2
ff ff
addsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14c(%rbp)
jmp    1345 <rk4+0x245>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rk4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r8,%r12
movapd %xmm1,0x60(%rsp)
movsd  0xede(%rip),%xmm7
mulsd  %xmm1,%xmm7
movapd %xmm7,%xmm6
addsd  %xmm0,%xmm6
test   %edx,%edx
movsd  %xmm0,0x8(%rsp)
movapd %xmm6,0xd0(%rsp)
jle    115b <rk4+0x5b>
mov    %rcx,%r14
mov    %edx,%r13d
mov    %rsi,%r15
mov    %rdi,%rbx
mov    %edx,%ebp
cmp    $0x4,%edx
jae    1173 <rk4+0x73>
xor    %eax,%eax
jmp    1270 <rk4+0x170>
lea    0x10(%rsp),%rdi
lea    0x70(%rsp),%rsi
movapd %xmm6,%xmm0
mov    $0x1,%al
call   *%r12
jmp    12cd <rk4+0x1cd>
mov    %ebp,%eax
and    $0xfffffffc,%eax
movapd %xmm7,%xmm5
unpcklpd %xmm7,%xmm5
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     15ab <rk4+0x4ab>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd (%r15,%rcx,8),%xmm3
movupd 0x10(%r15,%rcx,8),%xmm4
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm4
addpd  %xmm2,%xmm4
movapd %xmm3,0x10(%rsp,%rcx,8)
movapd %xmm4,0x20(%rsp,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm1
movupd 0x30(%rbx,%rcx,8),%xmm2
movupd 0x20(%r15,%rcx,8),%xmm3
movupd 0x30(%r15,%rcx,8),%xmm4
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm4
addpd  %xmm2,%xmm4
movapd %xmm3,0x30(%rsp,%rcx,8)
movapd %xmm4,0x40(%rsp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    11b0 <rk4+0xb0>
test   $0x1,%dl
je     125d <rk4+0x15d>
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd (%r15,%rcx,8),%xmm3
movupd 0x10(%r15,%rcx,8),%xmm4
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm4
addpd  %xmm2,%xmm4
movapd %xmm3,0x10(%rsp,%rcx,8)
movapd %xmm4,0x20(%rsp,%rcx,8)
cmp    %rbp,%rax
je     128e <rk4+0x18e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1270 <rk4+0x170>
movapd %xmm7,0xc0(%rsp)
lea    0x10(%rsp),%rdi
lea    0x70(%rsp),%rsi
movapd %xmm6,%xmm0
mov    $0x1,%al
call   *%r12
test   %r13d,%r13d
jle    12cd <rk4+0x1cd>
movaps 0xd0(%rsp),%xmm0
cmp    $0x4,%r13d
jae    1318 <rk4+0x218>
xor    %eax,%eax
movapd 0xc0(%rsp),%xmm5
jmp    1410 <rk4+0x310>
lea    0x10(%rsp),%rdi
lea    0xe0(%rsp),%rsi
movaps 0xd0(%rsp),%xmm0
mov    $0x1,%al
call   *%r12
movapd 0x60(%rsp),%xmm5
movsd  0x8(%rsp),%xmm0
addsd  %xmm5,%xmm0
lea    0x10(%rsp),%rdi
lea    0x70(%rsp),%rsi
mov    $0x1,%al
call   *%r12
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ebp,%eax
and    $0xfffffffc,%eax
movapd 0xc0(%rsp),%xmm5
movapd %xmm5,%xmm4
unpcklpd %xmm5,%xmm4
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1739 <rk4+0x639>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nop
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movapd 0x70(%rsp,%rcx,8),%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm1,%xmm3
movapd 0x80(%rsp,%rcx,8),%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm3,0x10(%rsp,%rcx,8)
movapd %xmm1,0x20(%rsp,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm1
movupd 0x30(%rbx,%rcx,8),%xmm2
movapd 0x90(%rsp,%rcx,8),%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm1,%xmm3
movapd 0xa0(%rsp,%rcx,8),%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm3,0x30(%rsp,%rcx,8)
movapd %xmm1,0x40(%rsp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1350 <rk4+0x250>
test   $0x1,%dl
je     1401 <rk4+0x301>
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movapd 0x70(%rsp,%rcx,8),%xmm3
mulpd  %xmm4,%xmm3
mulpd  0x80(%rsp,%rcx,8),%xmm4
addpd  %xmm1,%xmm3
addpd  %xmm2,%xmm4
movapd %xmm3,0x10(%rsp,%rcx,8)
movapd %xmm4,0x20(%rsp,%rcx,8)
cmp    %rbp,%rax
je     142e <rk4+0x32e>
cs nopw 0x0(%rax,%rax,1)
movsd  0x70(%rsp,%rax,8),%xmm1
mulsd  %xmm5,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x10(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1410 <rk4+0x310>
lea    0x10(%rsp),%rdi
lea    0xe0(%rsp),%rsi
mov    $0x1,%al
call   *%r12
test   %r13d,%r13d
movapd 0x60(%rsp),%xmm5
movsd  0x8(%rsp),%xmm0
jle    12f3 <rk4+0x1f3>
cmp    $0x1,%r13d
jne    1462 <rk4+0x362>
xor    %eax,%eax
jmp    1540 <rk4+0x440>
mov    %ebp,%eax
and    $0xfffffffe,%eax
movapd %xmm5,%xmm6
unpcklpd %xmm5,%xmm6
lea    -0x2(%rax),%rcx
mov    %rcx,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1749 <rk4+0x649>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nop
movupd (%rbx,%rcx,8),%xmm1
movapd 0xe0(%rsp,%rcx,8),%xmm2
movapd 0xf0(%rsp,%rcx,8),%xmm3
movapd %xmm6,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm4,0x10(%rsp,%rcx,8)
addpd  0x70(%rsp,%rcx,8),%xmm2
movapd %xmm2,0xe0(%rsp,%rcx,8)
movupd 0x10(%rbx,%rcx,8),%xmm1
movapd %xmm6,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm1,%xmm2
addpd  0x80(%rsp,%rcx,8),%xmm3
movapd %xmm2,0x20(%rsp,%rcx,8)
movapd %xmm3,0xf0(%rsp,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1490 <rk4+0x390>
test   $0x1,%dl
je     152c <rk4+0x42c>
movupd (%rbx,%rcx,8),%xmm1
movapd 0xe0(%rsp,%rcx,8),%xmm2
mulpd  %xmm2,%xmm6
addpd  %xmm1,%xmm6
movapd %xmm6,0x10(%rsp,%rcx,8)
addpd  0x70(%rsp,%rcx,8),%xmm2
movapd %xmm2,0xe0(%rsp,%rcx,8)
cmp    %rbp,%rax
je     1574 <rk4+0x474>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0xe0(%rsp,%rax,8),%xmm2
movapd %xmm5,%xmm1
mulsd  %xmm2,%xmm1
addsd  (%rbx,%rax,8),%xmm1
addsd  0x70(%rsp,%rax,8),%xmm2
movsd  %xmm1,0x10(%rsp,%rax,8)
movsd  %xmm2,0xe0(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1540 <rk4+0x440>
addsd  %xmm5,%xmm0
lea    0x10(%rsp),%rdi
lea    0x70(%rsp),%rsi
mov    $0x1,%al
call   *%r12
movapd 0x60(%rsp),%xmm7
test   %r13d,%r13d
jle    1306 <rk4+0x206>
divsd  0xa6a(%rip),%xmm7
cmp    $0x4,%r13d
jae    15bb <rk4+0x4bb>
xor    %eax,%eax
jmp    1688 <rk4+0x588>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1229 <rk4+0x129>
jmp    125d <rk4+0x15d>
lea    (%r14,%rbp,8),%rax
lea    (%rbx,%rbp,8),%rcx
cmp    %r14,%rcx
seta   %dil
lea    (%r15,%rbp,8),%rcx
cmp    %rbx,%rax
seta   %dl
cmp    %r14,%rcx
seta   %cl
cmp    %r15,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%dil
jne    1688 <rk4+0x588>
and    %sil,%cl
jne    1688 <rk4+0x588>
mov    %ebp,%eax
and    $0xfffffffc,%eax
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
lea    0x0(,%rbp,8),%rcx
and    $0xffffffffffffffe0,%rcx
xor    %edx,%edx
movupd (%rbx,%rdx,1),%xmm1
movupd 0x10(%rbx,%rdx,1),%xmm2
movupd (%r15,%rdx,1),%xmm3
movupd 0x10(%r15,%rdx,1),%xmm4
addpd  0x70(%rsp,%rdx,1),%xmm3
addpd  0x80(%rsp,%rdx,1),%xmm4
movapd 0xe0(%rsp,%rdx,1),%xmm5
movapd 0xf0(%rsp,%rdx,1),%xmm6
addpd  %xmm5,%xmm5
addpd  %xmm3,%xmm5
addpd  %xmm6,%xmm6
addpd  %xmm4,%xmm6
mulpd  %xmm0,%xmm5
addpd  %xmm1,%xmm5
mulpd  %xmm0,%xmm6
addpd  %xmm2,%xmm6
movupd %xmm5,(%r14,%rdx,1)
movupd %xmm6,0x10(%r14,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rcx
jne    1610 <rk4+0x510>
cmp    %rbp,%rax
je     1306 <rk4+0x206>
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     16c4 <rk4+0x5c4>
movsd  (%r15,%rax,8),%xmm0
addsd  0x70(%rsp,%rax,8),%xmm0
movsd  0xe0(%rsp,%rax,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm7,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
or     $0x1,%rax
add    %rbp,%rcx
je     1306 <rk4+0x206>
nopl   (%rax)
movsd  (%r15,%rax,8),%xmm0
addsd  0x70(%rsp,%rax,8),%xmm0
movsd  0xe0(%rsp,%rax,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm7,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
addsd  0x78(%rsp,%rax,8),%xmm0
movsd  0xe8(%rsp,%rax,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm7,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    16d0 <rk4+0x5d0>
jmp    1306 <rk4+0x206>
xor    %ecx,%ecx
test   $0x1,%dl
jne    13cf <rk4+0x2cf>
jmp    1401 <rk4+0x301>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1501 <rk4+0x401>
jmp    152c <rk4+0x42c>

LLVM IR (-O0):
define void @rk4(double* %0, double* %1, i32 %2, double %3, double %4, double* %5, i32 (...)* %6) {
%8 = alloca double*
%9 = alloca double*
%10 = alloca i32
%11 = alloca double
%12 = alloca double
%13 = alloca double*
%14 = alloca i32 (...)*
%15 = alloca [10 x double]
%16 = alloca [10 x double]
%17 = alloca [10 x double]
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca i32
store double* %0, double** %8
store double* %1, double** %9
store i32 %2, i32* %10
store double %3, double* %11
store double %4, double* %12
store double* %5, double** %13
store i32 (...)* %6, i32 (...)** %14
%22 = load double, double* %12
%23 = fmul double %22, 5.000000e-01
store double %23, double* %18
%24 = load double, double* %12
%25 = fdiv double %24, 6.000000e+00
store double %25, double* %19
%26 = load double, double* %11
%27 = load double, double* %18
%28 = fadd double %26, %27
store double %28, double* %20
store i32 0, i32* %21
br label %29
29: ; preds = %49, %7
%30 = load i32, i32* %21
%31 = load i32, i32* %10
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %52
33: ; preds = %29
%34 = load double*, double** %8
%35 = load i32, i32* %21
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds double, double* %34, i64 %36
%38 = load double, double* %37
%39 = load double, double* %18
%40 = load double*, double** %9
%41 = load i32, i32* %21
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds double, double* %40, i64 %42
%44 = load double, double* %43
%45 = call double @llvm.fmuladd.f64(double %39, double %44, double %38)
%46 = load i32, i32* %21
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [10 x double], [10 x double]* %15, i64 0, i64 %47
store double %45, double* %48
br label %49
49: ; preds = %33
%50 = load i32, i32* %21
%51 = add nsw i32 %50, 1
store i32 %51, i32* %21
br label %29
52: ; preds = %29
%53 = load i32 (...)*, i32 (...)** %14
%54 = load double, double* %20
%55 = getelementptr inbounds [10 x double], [10 x double]* %15, i64 0, i64 0
%56 = getelementptr inbounds [10 x double], [10 x double]* %16, i64 0, i64 0
%57 = bitcast i32 (...)* %53 to i32 (double, double*, double*, ...)*
%58 = call i32 (double, double*, double*, ...) %57(double %54, double* %55, double* %56)
store i32 0, i32* %21
br label %59
59: ; preds = %78, %52
%60 = load i32, i32* %21
%61 = load i32, i32* %10
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %81
63: ; preds = %59
%64 = load double*, double** %8
%65 = load i32, i32* %21
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds double, double* %64, i64 %66
%68 = load double, double* %67
%69 = load double, double* %18
%70 = load i32, i32* %21
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [10 x double], [10 x double]* %16, i64 0, i64 %71
%73 = load double, double* %72
%74 = call double @llvm.fmuladd.f64(double %69, double %73, double %68)
%75 = load i32, i32* %21
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [10 x double], [10 x double]* %15, i64 0, i64 %76
store double %74, double* %77
br label %78
78: ; preds = %63
%79 = load i32, i32* %21
%80 = add nsw i32 %79, 1
store i32 %80, i32* %21
br label %59
81: ; preds = %59
%82 = load i32 (...)*, i32 (...)** %14
%83 = load double, double* %20
%84 = getelementptr inbounds [10 x double], [10 x double]* %15, i64 0, i64 0
%85 = getelementptr inbounds [10 x double], [10 x double]* %17, i64 0, i64 0
%86 = bitcast i32 (...)* %82 to i32 (double, double*, double*, ...)*
%87 = call i32 (double, double*, double*, ...) %86(double %83, double* %84, double* %85)
store i32 0, i32* %21
br label %88
88: ; preds = %119, %81
%89 = load i32, i32* %21
%90 = load i32, i32* %10
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %122
92: ; preds = %88
%93 = load double*, double** %8
%94 = load i32, i32* %21
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %93, i64 %95
%97 = load double, double* %96
%98 = load double, double* %12
%99 = load i32, i32* %21
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [10 x double], [10 x double]* %17, i64 0, i64 %100
%102 = load double, double* %101
%103 = call double @llvm.fmuladd.f64(double %98, double %102, double %97)
%104 = load i32, i32* %21
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [10 x double], [10 x double]* %15, i64 0, i64 %105
store double %103, double* %106
%107 = load i32, i32* %21
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [10 x double], [10 x double]* %16, i64 0, i64 %108
%110 = load double, double* %109
%111 = load i32, i32* %21
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [10 x double], [10 x double]* %17, i64 0, i64 %112
%114 = load double, double* %113
%115 = fadd double %110, %114
%116 = load i32, i32* %21
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [10 x double], [10 x double]* %17, i64 0, i64 %117
store double %115, double* %118
br label %119
119: ; preds = %92
%120 = load i32, i32* %21
%121 = add nsw i32 %120, 1
store i32 %121, i32* %21
br label %88
122: ; preds = %88
%123 = load i32 (...)*, i32 (...)** %14
%124 = load double, double* %11
%125 = load double, double* %12
%126 = fadd double %124, %125
%127 = getelementptr inbounds [10 x double], [10 x double]* %15, i64 0, i64 0
%128 = getelementptr inbounds [10 x double], [10 x double]* %16, i64 0, i64 0
%129 = bitcast i32 (...)* %123 to i32 (double, double*, double*, ...)*
%130 = call i32 (double, double*, double*, ...) %129(double %126, double* %127, double* %128)
store i32 0, i32* %21
br label %131
131: ; preds = %162, %122
%132 = load i32, i32* %21
%133 = load i32, i32* %10
%134 = icmp slt i32 %132, %133
br i1 %134, label %135, label %165
135: ; preds = %131
%136 = load double*, double** %8
%137 = load i32, i32* %21
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
%140 = load double, double* %139
%141 = load double, double* %19
%142 = load double*, double** %9
%143 = load i32, i32* %21
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds double, double* %142, i64 %144
%146 = load double, double* %145
%147 = load i32, i32* %21
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [10 x double], [10 x double]* %16, i64 0, i64 %148
%150 = load double, double* %149
%151 = fadd double %146, %150
%152 = load i32, i32* %21
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [10 x double], [10 x double]* %17, i64 0, i64 %153
%155 = load double, double* %154
%156 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %155, double %151)
%157 = call double @llvm.fmuladd.f64(double %141, double %156, double %140)
%158 = load double*, double** %13
%159 = load i32, i32* %21
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double, double* %158, i64 %160
store double %157, double* %161
br label %162
162: ; preds = %135
%163 = load i32, i32* %21
%164 = add nsw i32 %163, 1
store i32 %164, i32* %21
br label %131
165: ; preds = %131
ret void
}

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