#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ diff(double *, double *, unsigned int const, double *,
                        double *);
int rk4(double *time, double vec1[], double vec2[], double rpar[],
        unsigned upar[]) {
  unsigned const n = upar[0];
  unsigned const m = upar[1];
  unsigned i = 0;
  double const h = rpar[1];
  double step = 0;
  double f1[n * 2], y1[n * 2];
  double f2[n * 2], y2[n * 2];
  double k0[n * 2], k1[n * 2], k2[n * 2], k3[n * 2];
  double l0[n * 2], l1[n * 2], l2[n * 2], l3[n * 2];
  for (step = 0; step < m; ++step) {
    diff(f1, f2, n, vec1, vec2);
    for (i = 0; i < n * 2; ++i) {
      k0[i] = f1[i];
      l0[i] = f2[i];
      y1[i] = vec1[i] + h * k0[i] / 2.;
      y2[i] = vec2[i] + h * l0[i] / 2.;
    }
    diff(f1, f2, n, y1, y2);
    for (i = 0; i < n * 2; ++i) {
      k1[i] = f1[i];
      l1[i] = f2[i];
      y1[i] = vec1[i] + h * k1[i] / 2.;
      y2[i] = vec2[i] + h * l1[i] / 2.;
    }
    diff(f1, f2, n, y1, y2);
    for (i = 0; i < n * 2; ++i) {
      k2[i] = f1[i];
      l2[i] = f2[i];
      y1[i] = vec1[i] + h * k2[i];
      y2[i] = vec2[i] + h * l2[i];
    }
    diff(f1, f2, n, y1, y2);
    for (i = 0; i < n * 2; ++i) {
      k3[i] = f1[i];
      l3[i] = f2[i];
      vec1[i] += h * (k0[i] + 2. * k1[i] + 2. * k2[i] + k3[i]) / 6.;
      vec2[i] += h * (l0[i] + 2. * l1[i] + 2. * l2[i] + l3[i]) / 6.;
    }
    *time += h;
  }
  return 0;
}


x86 assembly (clang, -O0):
<rk4>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x110,%rsp
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x30(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rsp,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x120(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x118(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x110(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x108(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x80(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x100(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x88(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xf8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x90(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xf0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x98(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xe8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa0(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xe0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa8(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xb0(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xb8(%rbp)
mov    -0x3c(%rbp),%eax
add    %eax,%eax
mov    %rax,%rdx
shl    $0x3,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xc8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xc0(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
mov    -0x40(%rbp),%eax
cvtsi2sd %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1798 <rk4+0x688>
mov    -0x110(%rbp),%rsi
mov    -0x120(%rbp),%rdi
mov    -0x3c(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
call   1030 <diff@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jae    1418 <rk4+0x308>
mov    -0x108(%rbp),%rax
mov    -0xe0(%rbp),%rcx
mov    -0x118(%rbp),%rdx
mov    -0x100(%rbp),%rsi
mov    -0x110(%rbp),%rdi
mov    -0x120(%rbp),%r8
mov    -0x44(%rbp),%r9d
movsd  (%r8,%r9,8),%xmm0
mov    -0x44(%rbp),%r8d
movsd  %xmm0,(%rsi,%r8,8)
mov    -0x44(%rbp),%r8d
movsd  (%rdi,%r8,8),%xmm0
mov    -0x44(%rbp),%edi
movsd  %xmm0,(%rcx,%rdi,8)
mov    -0x20(%rbp),%rdi
mov    -0x44(%rbp),%r8d
movsd  (%rdi,%r8,8),%xmm0
movsd  -0x50(%rbp),%xmm1
mov    -0x44(%rbp),%edi
mulsd  (%rsi,%rdi,8),%xmm1
movsd  0xc47(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%esi
movsd  %xmm0,(%rdx,%rsi,8)
mov    -0x28(%rbp),%rdx
mov    -0x44(%rbp),%esi
movsd  (%rdx,%rsi,8),%xmm0
movsd  -0x50(%rbp),%xmm1
mov    -0x44(%rbp),%edx
mulsd  (%rcx,%rdx,8),%xmm1
movsd  0xc16(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1345 <rk4+0x235>
mov    -0x108(%rbp),%r8
mov    -0x118(%rbp),%rcx
mov    -0x110(%rbp),%rsi
mov    -0x120(%rbp),%rdi
mov    -0x3c(%rbp),%edx
call   1030 <diff@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jae    1516 <rk4+0x406>
mov    -0x108(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    -0x118(%rbp),%rdx
mov    -0xf8(%rbp),%rsi
mov    -0x110(%rbp),%rdi
mov    -0x120(%rbp),%r8
mov    -0x44(%rbp),%r9d
movsd  (%r8,%r9,8),%xmm0
mov    -0x44(%rbp),%r8d
movsd  %xmm0,(%rsi,%r8,8)
mov    -0x44(%rbp),%r8d
movsd  (%rdi,%r8,8),%xmm0
mov    -0x44(%rbp),%edi
movsd  %xmm0,(%rcx,%rdi,8)
mov    -0x20(%rbp),%rdi
mov    -0x44(%rbp),%r8d
movsd  (%rdi,%r8,8),%xmm0
movsd  -0x50(%rbp),%xmm1
mov    -0x44(%rbp),%edi
mulsd  (%rsi,%rdi,8),%xmm1
movsd  0xb49(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%esi
movsd  %xmm0,(%rdx,%rsi,8)
mov    -0x28(%rbp),%rdx
mov    -0x44(%rbp),%esi
movsd  (%rdx,%rsi,8),%xmm0
movsd  -0x50(%rbp),%xmm1
mov    -0x44(%rbp),%edx
mulsd  (%rcx,%rdx,8),%xmm1
movsd  0xb18(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1443 <rk4+0x333>
mov    -0x108(%rbp),%r8
mov    -0x118(%rbp),%rcx
mov    -0x110(%rbp),%rsi
mov    -0x120(%rbp),%rdi
mov    -0x3c(%rbp),%edx
call   1030 <diff@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jae    1604 <rk4+0x4f4>
mov    -0x108(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    -0x118(%rbp),%rdx
mov    -0xf0(%rbp),%rsi
mov    -0x110(%rbp),%rdi
mov    -0x120(%rbp),%r8
mov    -0x44(%rbp),%r9d
movsd  (%r8,%r9,8),%xmm0
mov    -0x44(%rbp),%r8d
movsd  %xmm0,(%rsi,%r8,8)
mov    -0x44(%rbp),%r8d
movsd  (%rdi,%r8,8),%xmm0
mov    -0x44(%rbp),%edi
movsd  %xmm0,(%rcx,%rdi,8)
mov    -0x20(%rbp),%rdi
mov    -0x44(%rbp),%r8d
movsd  (%rdi,%r8,8),%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0x44(%rbp),%edi
movsd  (%rsi,%rdi,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%esi
movsd  %xmm0,(%rdx,%rsi,8)
mov    -0x28(%rbp),%rdx
mov    -0x44(%rbp),%esi
movsd  (%rdx,%rsi,8),%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0x44(%rbp),%edx
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1541 <rk4+0x431>
mov    -0x108(%rbp),%r8
mov    -0x118(%rbp),%rcx
mov    -0x110(%rbp),%rsi
mov    -0x120(%rbp),%rdi
mov    -0x3c(%rbp),%edx
call   1030 <diff@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jae    1770 <rk4+0x660>
mov    -0xc8(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    -0xd8(%rbp),%rdx
mov    -0xe0(%rbp),%rsi
mov    -0xe8(%rbp),%rdi
mov    -0xf0(%rbp),%r8
mov    -0xf8(%rbp),%r9
mov    -0x100(%rbp),%r10
mov    -0x110(%rbp),%r11
mov    -0x120(%rbp),%rbx
mov    -0x44(%rbp),%r14d
movsd  (%rbx,%r14,8),%xmm0
mov    -0x44(%rbp),%ebx
movsd  %xmm0,(%rdi,%rbx,8)
mov    -0x44(%rbp),%ebx
movsd  (%r11,%rbx,8),%xmm0
mov    -0x44(%rbp),%r11d
movsd  %xmm0,(%rax,%r11,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x44(%rbp),%r11d
movsd  (%r10,%r11,8),%xmm1
mov    -0x44(%rbp),%r10d
movsd  (%r9,%r10,8),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
mov    -0x44(%rbp),%r9d
movsd  (%r8,%r9,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mov    -0x44(%rbp),%r8d
addsd  (%rdi,%r8,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x914(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rdi
mov    -0x44(%rbp),%r8d
addsd  (%rdi,%r8,8),%xmm0
movsd  %xmm0,(%rdi,%r8,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x44(%rbp),%edi
movsd  (%rsi,%rdi,8),%xmm1
mov    -0x44(%rbp),%esi
movsd  (%rdx,%rsi,8),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
mov    -0x44(%rbp),%edx
movsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mov    -0x44(%rbp),%ecx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x8bb(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    162f <rk4+0x51f>
movsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  0x877(%rip),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1309 <rk4+0x1f9>
mov    -0x60(%rbp),%rax
mov    %rax,%rsp
xor    %eax,%eax
lea    -0x10(%rbp),%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<rk4>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rcx,-0x58(%rbp)
mov    %rdx,%r14
mov    %rsi,%r13
mov    %rdi,-0xc8(%rbp)
mov    (%r8),%eax
mov    0x4(%r8),%ecx
lea    (%rax,%rax,1),%esi
mov    %rsp,%rbx
mov    %rsi,-0x50(%rbp)
lea    0x0(,%rsi,8),%r9
sub    %r9,%rbx
mov    %rbx,%rsp
mov    %rsp,%rdi
sub    %r9,%rdi
mov    %rdi,-0x40(%rbp)
mov    %rdi,%rsp
mov    %rsp,%r15
sub    %r9,%r15
mov    %r15,%rsp
mov    %rsp,%r12
sub    %r9,%r12
mov    %r12,%rsp
mov    %rsp,%r10
sub    %r9,%r10
mov    %r10,%rsp
mov    %rsp,%r11
sub    %r9,%r11
mov    %r11,%rsp
mov    %rsp,%rdx
sub    %r9,%rdx
mov    %rdx,%rsp
mov    %rsp,%rdi
sub    %r9,%rdi
mov    %rdi,%rsp
mov    %rsp,%rsi
sub    %r9,%rsi
mov    %rsi,%rsp
mov    %rsp,%r8
mov    %r9,-0x48(%rbp)
sub    %r9,%r8
mov    %r8,-0x98(%rbp)
mov    %r8,%rsp
test   %ecx,%ecx
je     187c <rk4+0x75c>
cvtsi2sd %rcx,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x58(%rbp),%rcx
movsd  0x8(%rcx),%xmm3
mov    -0x50(%rbp),%r8
lea    0x0(%r13,%r8,8),%rcx
mov    %rcx,-0x58(%rbp)
lea    (%r14,%r8,8),%r9
add    $0xfffffffffffffffe,%r8
mov    %r8,-0x88(%rbp)
shr    %r8
add    $0x1,%r8
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
mov    %r8,%rcx
mov    %r8,-0x80(%rbp)
and    $0xfffffffffffffffe,%r8
mov    %r8,-0x78(%rbp)
cmp    %r13,%r9
seta   %r8b
cmp    %r14,-0x58(%rbp)
seta   %cl
and    %r8b,%cl
mov    %cl,-0x29(%rbp)
xorpd  %xmm1,%xmm1
mov    %rax,-0x38(%rbp)
mov    %r10,-0xb8(%rbp)
mov    %r11,-0xa8(%rbp)
mov    %rdx,-0x90(%rbp)
mov    %rdi,-0xb0(%rbp)
mov    %rsi,-0xa0(%rbp)
movapd %xmm3,-0xe0(%rbp)
ff
movapd %xmm4,-0x70(%rbp)
jmp    12f0 <rk4+0x1d0>
nopl   (%rax)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    %r12,%r8
call   1040 <diff@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    %r12,%r8
call   1040 <diff@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    %r12,%r8
call   1040 <diff@plt>
movapd -0xe0(%rbp),%xmm3
ff
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm1
addsd  0xd4e(%rip),%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
mov    -0x38(%rbp),%rax
jbe    187c <rk4+0x75c>
movsd  %xmm1,-0x58(%rbp)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %rax,%rdx
mov    %r13,%rcx
mov    %r14,%r8
call   1040 <diff@plt>
cmpl   $0x0,-0x50(%rbp)
je     1270 <rk4+0x150>
mov    -0xb8(%rbp),%rdi
mov    %rbx,%rsi
mov    -0x48(%rbp),%rdx
call   1030 <memcpy@plt>
mov    -0xb0(%rbp),%rdi
mov    %r15,%rsi
mov    -0x48(%rbp),%rdx
call   1030 <memcpy@plt>
cmpq   $0x0,-0x88(%rbp)
je     1780 <rk4+0x660>
mov    -0x78(%rbp),%rsi
xor    %eax,%eax
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
movapd -0x70(%rbp),%xmm2
movapd 0xc9e(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd 0x0(%r13,%rax,8),%xmm0
movapd (%rbx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movapd (%r15,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm1,(%rcx,%rax,8)
movupd (%r14,%rax,8),%xmm1
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,(%r12,%rax,8)
movupd 0x10(%r13,%rax,8),%xmm0
movapd 0x10(%rbx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movapd 0x10(%r15,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm1,0x10(%rcx,%rax,8)
movupd 0x10(%r14,%rax,8),%xmm1
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,0x10(%r12,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rsi
jne    1370 <rk4+0x250>
testb  $0x1,-0x80(%rbp)
je     143a <rk4+0x31a>
movupd 0x0(%r13,%rax,8),%xmm0
movapd (%rbx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movapd (%r15,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm1,(%rcx,%rax,8)
movupd (%r14,%rax,8),%xmm1
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,(%r12,%rax,8)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r12,%r8
call   1040 <diff@plt>
cmpl   $0x0,-0x50(%rbp)
je     1286 <rk4+0x166>
mov    -0xa8(%rbp),%rdi
mov    %rbx,%rsi
mov    -0x48(%rbp),%rdx
call   1030 <memcpy@plt>
mov    -0xa0(%rbp),%rdi
mov    %r15,%rsi
mov    -0x48(%rbp),%rdx
call   1030 <memcpy@plt>
cmpq   $0x0,-0x88(%rbp)
je     17a6 <rk4+0x686>
mov    -0x78(%rbp),%rsi
xor    %eax,%eax
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
movapd -0x70(%rbp),%xmm2
movapd 0xb5f(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rax,8),%xmm0
movapd (%rbx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movapd (%r15,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm1,(%rcx,%rax,8)
movupd (%r14,%rax,8),%xmm1
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,(%r12,%rax,8)
movupd 0x10(%r13,%rax,8),%xmm0
movapd 0x10(%rbx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movapd 0x10(%r15,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm1,0x10(%rcx,%rax,8)
movupd 0x10(%r14,%rax,8),%xmm1
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,0x10(%r12,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rsi
jne    14b0 <rk4+0x390>
testb  $0x1,-0x80(%rbp)
je     157a <rk4+0x45a>
movupd 0x0(%r13,%rax,8),%xmm0
movapd (%rbx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movapd (%r15,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm1,(%rcx,%rax,8)
movupd (%r14,%rax,8),%xmm1
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,(%r12,%rax,8)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r12,%r8
call   1040 <diff@plt>
cmpl   $0x0,-0x50(%rbp)
je     129c <rk4+0x17c>
mov    -0x90(%rbp),%rdi
mov    %rbx,%rsi
mov    -0x48(%rbp),%rdx
call   1030 <memcpy@plt>
mov    -0x98(%rbp),%rdi
mov    %r15,%rsi
mov    -0x48(%rbp),%rdx
call   1030 <memcpy@plt>
cmpq   $0x0,-0x88(%rbp)
je     17cc <rk4+0x6ac>
mov    -0x78(%rbp),%rsi
xor    %eax,%eax
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
movapd -0x70(%rbp),%xmm2
nopl   0x0(%rax)
movupd 0x0(%r13,%rax,8),%xmm0
movapd (%rbx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd (%r15,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm1,(%rcx,%rax,8)
movupd (%r14,%rax,8),%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,(%r12,%rax,8)
movupd 0x10(%r13,%rax,8),%xmm0
movapd 0x10(%rbx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd 0x10(%r15,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm1,0x10(%rcx,%rax,8)
movupd 0x10(%r14,%rax,8),%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x10(%r12,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rsi
jne    15e0 <rk4+0x4c0>
testb  $0x1,-0x80(%rbp)
je     168e <rk4+0x56e>
movupd 0x0(%r13,%rax,8),%xmm0
movapd (%rbx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd (%r15,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm1,(%rcx,%rax,8)
movupd (%r14,%rax,8),%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,(%r12,%rax,8)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r12,%r8
call   1040 <diff@plt>
movapd -0x70(%rbp),%xmm4
cmpl   $0x0,-0x50(%rbp)
mov    -0xb8(%rbp),%r10
mov    -0xa8(%rbp),%r11
mov    -0x90(%rbp),%rdx
mov    -0xb0(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0x98(%rbp),%rcx
movapd -0xe0(%rbp),%xmm3
ff
movsd  0x941(%rip),%xmm5
movapd 0x929(%rip),%xmm6
je     12ba <rk4+0x19a>
cmpb   $0x0,-0x29(%rbp)
je     17ea <rk4+0x6ca>
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%r15,%rax,1),%xmm0
movsd  (%r11,%rax,1),%xmm1
addsd  %xmm1,%xmm1
addsd  (%r10,%rax,1),%xmm1
movsd  (%rdx,%rax,1),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
addsd  (%rbx,%rax,1),%xmm2
mulsd  %xmm3,%xmm2
divsd  %xmm5,%xmm2
addsd  0x0(%r13,%rax,1),%xmm2
movsd  %xmm2,0x0(%r13,%rax,1)
movsd  (%rsi,%rax,1),%xmm1
addsd  %xmm1,%xmm1
addsd  (%rdi,%rax,1),%xmm1
movsd  (%rcx,%rax,1),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm3,%xmm2
divsd  %xmm5,%xmm2
addsd  (%r14,%rax,1),%xmm2
movsd  %xmm2,(%r14,%rax,1)
add    $0x8,%rax
cmp    %rax,-0x48(%rbp)
jne    1700 <rk4+0x5e0>
jmp    12ba <rk4+0x19a>
xor    %eax,%eax
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
movapd -0x70(%rbp),%xmm2
movapd 0x869(%rip),%xmm3
testb  $0x1,-0x80(%rbp)
jne    13ff <rk4+0x2df>
jmp    143a <rk4+0x31a>
xor    %eax,%eax
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
movapd -0x70(%rbp),%xmm2
movapd 0x843(%rip),%xmm3
testb  $0x1,-0x80(%rbp)
jne    153f <rk4+0x41f>
jmp    157a <rk4+0x45a>
xor    %eax,%eax
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
movapd -0x70(%rbp),%xmm2
testb  $0x1,-0x80(%rbp)
jne    165b <rk4+0x53b>
jmp    168e <rk4+0x56e>
xor    %eax,%eax
nopl   0x0(%rax)
movapd (%r15,%rax,8),%xmm0
movapd (%r11,%rax,8),%xmm1
addpd  %xmm1,%xmm1
addpd  (%r10,%rax,8),%xmm1
movapd (%rdx,%rax,8),%xmm2
addpd  %xmm2,%xmm2
addpd  %xmm1,%xmm2
addpd  (%rbx,%rax,8),%xmm2
mulpd  %xmm4,%xmm2
divpd  %xmm6,%xmm2
movupd 0x0(%r13,%rax,8),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x0(%r13,%rax,8)
movapd (%rsi,%rax,8),%xmm1
addpd  %xmm1,%xmm1
addpd  (%rdi,%rax,8),%xmm1
movapd (%rcx,%rax,8),%xmm2
addpd  %xmm2,%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm4,%xmm2
divpd  %xmm6,%xmm2
movupd (%r14,%rax,8),%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,-0x50(%rbp)
jne    17f0 <rk4+0x6d0>
jmp    12ba <rk4+0x19a>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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