#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*/ kepler(double, double *, double *);
int rkStep(int neqn, double *y, double *yp, double t, double dt) {
  double k1[neqn], k2[neqn], k3[neqn], k4[neqn], yt[neqn];
  int i;
  kepler(t, y, k1);
  for (i = 0; i < neqn; i++) {
    yt[i] = y[i] + 0.5 * dt * k1[i];
  }
  kepler(t, yt, k2);
  for (i = 0; i < neqn; i++) {
    yt[i] = y[i] + 0.5 * dt * k2[i];
  }
  kepler(t, yt, k3);
  for (i = 0; i < neqn; i++) {
    yt[i] = y[i] + dt * k3[i];
  }
  kepler(t, yt, k4);
  for (i = 0; i < neqn; i++) {
    yp[i] = y[i] + dt * (k1[i] + 2.0 * (k2[i] + k3[i]) + k4[i]) / 6.0;
  }
  return 0;
}


x86 assembly (clang, -O0):
<rkStep>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
mov    -0x4(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
lea    0xf(,%rax,8),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rsi
sub    %rcx,%rsi
mov    %rsi,-0x88(%rbp)
mov    %rsi,%rsp
mov    %rax,-0x38(%rbp)
mov    -0x4(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x80(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    -0x4(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x78(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
mov    -0x4(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x70(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rdi
call   1030 <kepler@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1248 <rkStep+0x138>
mov    -0x68(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    -0x10(%rbp),%rdx
movslq -0x5c(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm1
movsd  0xded(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movslq -0x5c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11ef <rkStep+0xdf>
mov    -0x80(%rbp),%rsi
mov    -0x68(%rbp),%rdi
movsd  -0x20(%rbp),%xmm0
call   1030 <kepler@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12b7 <rkStep+0x1a7>
mov    -0x68(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    -0x10(%rbp),%rdx
movslq -0x5c(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm1
movsd  0xd7e(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movslq -0x5c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1261 <rkStep+0x151>
mov    -0x78(%rbp),%rsi
mov    -0x68(%rbp),%rdi
movsd  -0x20(%rbp),%xmm0
call   1030 <kepler@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    131e <rkStep+0x20e>
mov    -0x68(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    -0x10(%rbp),%rdx
movslq -0x5c(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movslq -0x5c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12d0 <rkStep+0x1c0>
mov    -0x70(%rbp),%rsi
mov    -0x68(%rbp),%rdi
movsd  -0x20(%rbp),%xmm0
call   1030 <kepler@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13c4 <rkStep+0x2b4>
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    -0x88(%rbp),%rsi
mov    -0x10(%rbp),%rdi
movslq -0x5c(%rbp),%r8
movsd  (%rdi,%r8,8),%xmm0
movsd  -0x28(%rbp),%xmm1
movslq -0x5c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm3
movslq -0x5c(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm2
movslq -0x5c(%rbp),%rdx
addsd  (%rcx,%rdx,8),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xc5f(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1337 <rkStep+0x227>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
xor    %eax,%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rkStep>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movapd %xmm1,-0x60(%rbp)
mov    %rdx,-0x68(%rbp)
mov    %rsi,%rbx
mov    %edi,-0x34(%rbp)
mov    %edi,%r13d
mov    %rsp,%r15
lea    0xf(,%r13,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    %rsp,%r14
sub    %rax,%r14
mov    %r14,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
movsd  %xmm0,-0x30(%rbp)
mov    %rsi,%rdi
mov    %r15,%rsi
call   1030 <kepler@plt>
mov    -0x34(%rbp),%eax
test   %eax,%eax
jle    11ad <rkStep+0x9d>
movsd  0xe6d(%rip),%xmm6
movapd -0x60(%rbp),%xmm0
mulsd  %xmm0,%xmm6
cmp    $0x4,%eax
jae    11c2 <rkStep+0xb2>
xor    %eax,%eax
movsd  -0x30(%rbp),%xmm0
jmp    12c0 <rkStep+0x1b0>
movsd  -0x30(%rbp),%xmm0
mov    %r12,%rdi
mov    %r14,%rsi
call   1030 <kepler@plt>
jmp    130f <rkStep+0x1ff>
mov    %r13d,%eax
and    $0xfffffffc,%eax
movapd %xmm6,%xmm5
unpcklpd %xmm6,%xmm5
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     13f9 <rkStep+0x2e9>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movsd  -0x30(%rbp),%xmm0
cs nopw 0x0(%rax,%rax,1)
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movapd (%r15,%rcx,8),%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movapd 0x10(%r15,%rcx,8),%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm3,(%r12,%rcx,8)
movapd %xmm1,0x10(%r12,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm1
movupd 0x30(%rbx,%rcx,8),%xmm2
movapd 0x20(%r15,%rcx,8),%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movapd 0x30(%r15,%rcx,8),%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm3,0x20(%r12,%rcx,8)
movapd %xmm1,0x30(%r12,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1200 <rkStep+0xf0>
test   $0x1,%dl
je     12ad <rkStep+0x19d>
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movapd (%r15,%rcx,8),%xmm3
mulpd  %xmm5,%xmm3
mulpd  0x10(%r15,%rcx,8),%xmm5
addpd  %xmm1,%xmm3
addpd  %xmm2,%xmm5
movapd %xmm3,(%r12,%rcx,8)
movapd %xmm5,0x10(%r12,%rcx,8)
cmp    %r13,%rax
je     12de <rkStep+0x1ce>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    12c0 <rkStep+0x1b0>
movapd %xmm6,-0x80(%rbp)
mov    %r12,%rdi
mov    %r14,%rsi
call   1030 <kepler@plt>
mov    -0x34(%rbp),%eax
test   %eax,%eax
jle    130f <rkStep+0x1ff>
cmp    $0x4,%eax
jae    1342 <rkStep+0x232>
xor    %eax,%eax
mov    -0x40(%rbp),%rsi
movsd  -0x30(%rbp),%xmm0
movapd -0x80(%rbp),%xmm5
jmp    1460 <rkStep+0x350>
movsd  -0x30(%rbp),%xmm0
mov    %r12,%rdi
mov    -0x40(%rbp),%rsi
call   1030 <kepler@plt>
movsd  -0x30(%rbp),%xmm0
mov    %r12,%rdi
mov    -0x48(%rbp),%rsi
call   1030 <kepler@plt>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r13d,%eax
and    $0xfffffffc,%eax
movapd -0x80(%rbp),%xmm5
movapd %xmm5,%xmm4
unpcklpd %xmm5,%xmm4
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     140e <rkStep+0x2fe>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movapd (%r14,%rcx,8),%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm1,%xmm3
movapd 0x10(%r14,%rcx,8),%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm3,(%r12,%rcx,8)
movapd %xmm1,0x10(%r12,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm1
movupd 0x30(%rbx,%rcx,8),%xmm2
movapd 0x20(%r14,%rcx,8),%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm1,%xmm3
movapd 0x30(%r14,%rcx,8),%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm3,0x20(%r12,%rcx,8)
movapd %xmm1,0x30(%r12,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1380 <rkStep+0x270>
jmp    1410 <rkStep+0x300>
xor    %ecx,%ecx
movsd  -0x30(%rbp),%xmm0
test   $0x1,%dl
jne    127c <rkStep+0x16c>
jmp    12ad <rkStep+0x19d>
xor    %ecx,%ecx
test   $0x1,%dl
mov    -0x40(%rbp),%rsi
movsd  -0x30(%rbp),%xmm0
je     144f <rkStep+0x33f>
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movapd (%r14,%rcx,8),%xmm3
mulpd  %xmm4,%xmm3
mulpd  0x10(%r14,%rcx,8),%xmm4
addpd  %xmm1,%xmm3
addpd  %xmm2,%xmm4
movapd %xmm3,(%r12,%rcx,8)
movapd %xmm4,0x10(%r12,%rcx,8)
cmp    %r13,%rax
je     147e <rkStep+0x36e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r14,%rax,8),%xmm1
mulsd  %xmm5,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    1460 <rkStep+0x350>
mov    %r12,%rdi
call   1030 <kepler@plt>
mov    -0x34(%rbp),%eax
test   %eax,%eax
jle    1320 <rkStep+0x210>
cmp    $0x4,%eax
jae    14ab <rkStep+0x39b>
xor    %eax,%eax
movapd -0x60(%rbp),%xmm4
mov    -0x40(%rbp),%rdi
movsd  -0x30(%rbp),%xmm0
jmp    15b0 <rkStep+0x4a0>
mov    %r13d,%eax
and    $0xfffffffc,%eax
movapd -0x60(%rbp),%xmm4
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1565 <rkStep+0x455>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
mov    -0x40(%rbp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movapd (%rdi,%rcx,8),%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movapd 0x10(%rdi,%rcx,8),%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm3,(%r12,%rcx,8)
movapd %xmm1,0x10(%r12,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm1
movupd 0x30(%rbx,%rcx,8),%xmm2
movapd 0x20(%rdi,%rcx,8),%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movapd 0x30(%rdi,%rcx,8),%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm3,0x20(%r12,%rcx,8)
movapd %xmm1,0x30(%r12,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    14f0 <rkStep+0x3e0>
jmp    156b <rkStep+0x45b>
xor    %ecx,%ecx
mov    -0x40(%rbp),%rdi
test   $0x1,%dl
movsd  -0x30(%rbp),%xmm0
je     15a4 <rkStep+0x494>
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movapd (%rdi,%rcx,8),%xmm3
mulpd  %xmm5,%xmm3
mulpd  0x10(%rdi,%rcx,8),%xmm5
addpd  %xmm1,%xmm3
addpd  %xmm2,%xmm5
movapd %xmm3,(%r12,%rcx,8)
movapd %xmm5,0x10(%r12,%rcx,8)
cmp    %r13,%rax
je     15cd <rkStep+0x4bd>
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    15b0 <rkStep+0x4a0>
mov    %r12,%rdi
mov    -0x48(%rbp),%r12
mov    %r12,%rsi
call   1030 <kepler@plt>
movapd -0x60(%rbp),%xmm4
mov    -0x34(%rbp),%eax
test   %eax,%eax
mov    -0x68(%rbp),%rcx
jle    1331 <rkStep+0x221>
cmp    $0x1,%eax
je     1607 <rkStep+0x4f7>
lea    (%rbx,%r13,8),%rax
cmp    %rcx,%rax
jbe    1679 <rkStep+0x569>
lea    (%rcx,%r13,8),%rax
cmp    %rbx,%rax
jbe    1679 <rkStep+0x569>
xor    %r8d,%r8d
lea    (%rcx,%r8,8),%r9
lea    (%r12,%r8,8),%rdx
mov    -0x40(%rbp),%rax
lea    (%rax,%r8,8),%rsi
lea    (%r14,%r8,8),%rdi
lea    (%r15,%r8,8),%rax
lea    (%rbx,%r8,8),%rbx
sub    %r8,%r13
xor    %ecx,%ecx
movsd  0x9d5(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%rcx,8),%xmm1
addsd  (%rsi,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
addsd  (%rax,%rcx,8),%xmm1
addsd  (%rdx,%rcx,8),%xmm1
mulsd  %xmm4,%xmm1
divsd  %xmm0,%xmm1
addsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%r9,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1640 <rkStep+0x530>
jmp    1331 <rkStep+0x221>
mov    %r13d,%r8d
and    $0xfffffffe,%r8d
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
xor    %eax,%eax
movapd 0x97e(%rip),%xmm1
mov    -0x40(%rbp),%rdx
cs nopw 0x0(%rax,%rax,1)
movapd (%r14,%rax,8),%xmm2
addpd  (%rdx,%rax,8),%xmm2
movupd (%rbx,%rax,8),%xmm3
addpd  %xmm2,%xmm2
addpd  (%r15,%rax,8),%xmm2
addpd  (%r12,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
divpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r8
jne    16a0 <rkStep+0x590>
cmp    %r13,%r8
je     1331 <rkStep+0x221>
jmp    160a <rkStep+0x4fa>

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

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