#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*/ derivs_three(double *, double *, double *, double *);
void leech_three_signal_rk4(double *Kt, double *y, const double dt,
                            const unsigned N, const unsigned stride,
                            const double *p, double *kij, double *output) {
  unsigned i, j, k, nKt = 0;
  double dt2, dt6;
  double y1[9], y2[9], k1[9], k2[9], k3[9], k4[9], P[12];
  dt2 = dt / 2.;
  dt6 = dt / 6.;
  for (j = 0; j < 12; j++)
    P[j] = p[j + 1];
  for (j = 0; j < 3; j++)
    output[j] = y[3 * j];
  for (i = 1; i < N; i++) {
    for (j = 0; j < stride; j++) {
      kij[2] = Kt[nKt];
      kij[3] = Kt[nKt++];
      derivs_three(y, k1, P, kij);
      for (k = 0; k < 9; k++)
        y1[k] = y[k] + k1[k] * dt2;
      kij[2] = Kt[nKt];
      kij[3] = Kt[nKt++];
      derivs_three(y1, k2, P, kij);
      for (k = 0; k < 9; k++)
        y2[k] = y[k] + k2[k] * dt2;
      derivs_three(y2, k3, P, kij);
      for (k = 0; k < 9; k++)
        y2[k] = y[k] + k3[k] * dt;
      kij[2] = Kt[nKt];
      kij[3] = Kt[nKt];
      derivs_three(y2, k4, P, kij);
      for (k = 0; k < 9; k++)
        y[k] += dt6 * (k1[k] + 2. * (k2[k] + k3[k]) + k4[k]);
    }
    for (j = 0; j < 3; j++)
      output[3 * i + j] = y[3 * j];
  }
}


x86 assembly (clang, -O0):
<leech_three_signal_rk4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x290,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x40(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  0xeba(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  0xe9c(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0xc,-0x38(%rbp)
jae    11a9 <leech_three_signal_rk4+0x99>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%eax
movsd  %xmm0,-0x290(%rbp,%rax,8)
ff ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1174 <leech_three_signal_rk4+0x64>
movl   $0x0,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jae    11e3 <leech_three_signal_rk4+0xd3>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x38(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11b0 <leech_three_signal_rk4+0xa0>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    14db <leech_three_signal_rk4+0x3cb>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jae    1488 <leech_three_signal_rk4+0x378>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rdi
lea    -0x140(%rbp),%rsi
lea    -0x290(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1030 <derivs_three@plt>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x9,-0x3c(%rbp)
jae    12a8 <leech_three_signal_rk4+0x198>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x3c(%rbp),%eax
movsd  -0x140(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x3c(%rbp),%eax
movsd  %xmm0,-0xa0(%rbp,%rax,8)
ff ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    125f <leech_three_signal_rk4+0x14f>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x18(%rax)
lea    -0xa0(%rbp),%rdi
lea    -0x190(%rbp),%rsi
lea    -0x290(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1030 <derivs_three@plt>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x9,-0x3c(%rbp)
jae    134a <leech_three_signal_rk4+0x23a>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x3c(%rbp),%eax
movsd  -0x190(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x3c(%rbp),%eax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1301 <leech_three_signal_rk4+0x1f1>
lea    -0xf0(%rbp),%rdi
lea    -0x1e0(%rbp),%rsi
lea    -0x290(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1030 <derivs_three@plt>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x9,-0x3c(%rbp)
jae    13b8 <leech_three_signal_rk4+0x2a8>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x3c(%rbp),%eax
movsd  -0x1e0(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x3c(%rbp),%eax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    136f <leech_three_signal_rk4+0x25f>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x18(%rax)
lea    -0xf0(%rbp),%rdi
lea    -0x230(%rbp),%rsi
lea    -0x290(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1030 <derivs_three@plt>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x9,-0x3c(%rbp)
jae    1475 <leech_three_signal_rk4+0x365>
movsd  -0x50(%rbp),%xmm0
mov    -0x3c(%rbp),%eax
movsd  -0x140(%rbp,%rax,8),%xmm1
ff ff
mov    -0x3c(%rbp),%eax
movsd  -0x190(%rbp,%rax,8),%xmm2
ff ff
mov    -0x3c(%rbp),%eax
addsd  -0x1e0(%rbp,%rax,8),%xmm2
ff ff
addsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
mov    -0x3c(%rbp),%eax
addsd  -0x230(%rbp,%rax,8),%xmm2
ff ff
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1407 <leech_three_signal_rk4+0x2f7>
jmp    147a <leech_three_signal_rk4+0x36a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11fd <leech_three_signal_rk4+0xed>
movl   $0x0,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jae    14c8 <leech_three_signal_rk4+0x3b8>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x38(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
imul   $0x3,-0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    148f <leech_three_signal_rk4+0x37f>
jmp    14cd <leech_three_signal_rk4+0x3bd>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ea <leech_three_signal_rk4+0xda>
add    $0x290,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<leech_three_signal_rk4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2c8,%rsp
mov    0x300(%rsp),%rax
movups 0x58(%r8),%xmm1
movaps %xmm1,0x2b0(%rsp)
movups 0x48(%r8),%xmm1
movaps %xmm1,0x2a0(%rsp)
movupd 0x8(%r8),%xmm4
movups 0x18(%r8),%xmm1
movupd 0x28(%r8),%xmm2
movupd 0x38(%r8),%xmm3
movapd %xmm3,0x290(%rsp)
movapd %xmm2,0x280(%rsp)
movaps %xmm1,0x270(%rsp)
movapd %xmm4,0x260(%rsp)
movsd  (%rsi),%xmm1
movsd  %xmm1,(%rax)
movsd  0x18(%rsi),%xmm1
movsd  %xmm1,0x8(%rax)
movsd  0x30(%rsi),%xmm1
movsd  %xmm1,0x10(%rax)
cmp    $0x2,%edx
jb     1651 <leech_three_signal_rk4+0x541>
mov    %r9,%rbx
mov    %rsi,%rbp
movsd  0xe50(%rip),%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm0,%xmm3
divsd  0xe48(%rip),%xmm3
mov    %edx,%eax
mov    %rax,0x8(%rsp)
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
movapd %xmm0,%xmm6
unpcklpd %xmm0,%xmm6
movapd %xmm3,%xmm7
unpcklpd %xmm3,%xmm7
xor    %r12d,%r12d
mov    $0x1,%r10d
lea    0x40(%rsp),%rsi
mov    %ecx,(%rsp)
movapd %xmm3,0x1b0(%rsp)
movapd %xmm7,0x1a0(%rsp)
mov    %rdi,0x18(%rsp)
movapd %xmm2,0x30(%rsp)
movapd %xmm6,0x190(%rsp)
movapd %xmm0,0x180(%rsp)
movapd %xmm5,0x20(%rsp)
mov    0x18(%rsp),%r14
jmp    1277 <leech_three_signal_rk4+0x167>
nopl   0x0(%rax)
movsd  0x0(%rbp),%xmm4
lea    (%r10,%r10,2),%eax
mov    0x300(%rsp),%rdx
movsd  %xmm4,(%rdx,%rax,8)
movsd  0x18(%rbp),%xmm1
lea    (%r10,%r10,2),%eax
add    $0x1,%eax
movsd  %xmm1,(%rdx,%rax,8)
movsd  0x30(%rbp),%xmm1
lea    (%r10,%r10,2),%eax
add    $0x2,%eax
movsd  %xmm1,(%rdx,%rax,8)
add    $0x1,%r10
cmp    0x8(%rsp),%r10
je     1651 <leech_three_signal_rk4+0x541>
test   %ecx,%ecx
je     1230 <leech_three_signal_rk4+0x120>
mov    %r10,0x10(%rsp)
mov    %ecx,0x4(%rsp)
mov    %r12d,%eax
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx)
mov    %rbp,%rdi
lea    0x260(%rsp),%r15
mov    %r15,%rdx
mov    %rbx,%rcx
call   1030 <derivs_three@plt>
movupd 0x0(%rbp),%xmm0
movapd 0x40(%rsp),%xmm1
movapd 0x20(%rsp),%xmm2
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x210(%rsp)
movupd 0x10(%rbp),%xmm0
movapd 0x50(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x220(%rsp)
movupd 0x20(%rbp),%xmm0
movapd 0x60(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x230(%rsp)
movupd 0x30(%rbp),%xmm0
movapd 0x70(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x240(%rsp)
movsd  0x80(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
addsd  0x40(%rbp),%xmm0
movsd  %xmm0,0x250(%rsp)
lea    0x1(%r12),%eax
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx)
lea    0x210(%rsp),%rdi
lea    0xe0(%rsp),%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
call   1030 <derivs_three@plt>
movupd 0x0(%rbp),%xmm0
movapd 0xe0(%rsp),%xmm1
movapd 0x20(%rsp),%xmm2
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x130(%rsp)
movupd 0x10(%rbp),%xmm0
movapd 0xf0(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x140(%rsp)
movupd 0x20(%rbp),%xmm0
movapd 0x100(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x150(%rsp)
movupd 0x30(%rbp),%xmm0
movapd 0x110(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x160(%rsp)
movsd  0x120(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
addsd  0x40(%rbp),%xmm0
movsd  %xmm0,0x170(%rsp)
lea    0x130(%rsp),%r13
mov    %r13,%rdi
lea    0x90(%rsp),%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
call   1030 <derivs_three@plt>
movapd 0x90(%rsp),%xmm0
movupd 0x0(%rbp),%xmm1
movapd 0x190(%rsp),%xmm2
mulpd  %xmm2,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,0x130(%rsp)
movupd 0x10(%rbp),%xmm0
movapd 0xa0(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x140(%rsp)
movupd 0x20(%rbp),%xmm0
movapd 0xb0(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x150(%rsp)
movupd 0x30(%rbp),%xmm0
movapd 0xc0(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x160(%rsp)
movsd  0xd0(%rsp),%xmm0
mulsd  0x180(%rsp),%xmm0
addsd  0x40(%rbp),%xmm0
add    $0x2,%r12d
movsd  %xmm0,0x170(%rsp)
movsd  (%r14,%r12,8),%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  (%r14,%r12,8),%xmm0
movsd  %xmm0,0x18(%rbx)
mov    %r13,%rdi
lea    0x1c0(%rsp),%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
call   1030 <derivs_three@plt>
mov    0x4(%rsp),%ecx
lea    0x40(%rsp),%rsi
movapd 0x1a0(%rsp),%xmm7
movapd 0xe0(%rsp),%xmm1
addpd  0x90(%rsp),%xmm1
addpd  %xmm1,%xmm1
addpd  0x40(%rsp),%xmm1
addpd  0x1c0(%rsp),%xmm1
movupd 0x0(%rbp),%xmm4
mulpd  %xmm7,%xmm1
addpd  %xmm1,%xmm4
movupd 0x10(%rbp),%xmm1
movupd 0x20(%rbp),%xmm2
movupd %xmm4,0x0(%rbp)
movapd 0xf0(%rsp),%xmm3
addpd  0xa0(%rsp),%xmm3
addpd  %xmm3,%xmm3
addpd  0x50(%rsp),%xmm3
addpd  0x1d0(%rsp),%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rbp)
movapd 0x1b0(%rsp),%xmm3
movapd 0x100(%rsp),%xmm1
addpd  0xb0(%rsp),%xmm1
addpd  %xmm1,%xmm1
addpd  0x60(%rsp),%xmm1
addpd  0x1e0(%rsp),%xmm1
mulpd  %xmm7,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x20(%rbp)
movapd 0x110(%rsp),%xmm1
addpd  0xc0(%rsp),%xmm1
addpd  %xmm1,%xmm1
addpd  0x70(%rsp),%xmm1
addpd  0x1f0(%rsp),%xmm1
movupd 0x30(%rbp),%xmm2
mulpd  %xmm7,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x30(%rbp)
movsd  0x120(%rsp),%xmm1
addsd  0xd0(%rsp),%xmm1
addsd  %xmm1,%xmm1
addsd  0x80(%rsp),%xmm1
addsd  0x200(%rsp),%xmm1
mulsd  %xmm3,%xmm1
addsd  0x40(%rbp),%xmm1
movsd  %xmm1,0x40(%rbp)
add    $0xffffffff,%ecx
jne    1280 <leech_three_signal_rk4+0x170>
mov    (%rsp),%ecx
mov    0x10(%rsp),%r10
jmp    1235 <leech_three_signal_rk4+0x125>
add    $0x2c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @leech_three_signal_rk4(double* nocapture %0, double* %1, double %2, i32 %3, i32 %4, double* nocapture %5, double* %6, double* nocapture writeonly %7) {
%9 = alloca [9 x double]
%10 = alloca [9 x double]
%11 = alloca [9 x double]
%12 = alloca [9 x double]
%13 = alloca [9 x double]
%14 = alloca [9 x double]
%15 = alloca [12 x double]
%16 = bitcast [12 x double]* %15 to i8*
%17 = bitcast [9 x double]* %9 to i8*
%18 = bitcast [9 x double]* %10 to i8*
%19 = bitcast [9 x double]* %11 to i8*
%20 = bitcast [9 x double]* %12 to i8*
%21 = bitcast [9 x double]* %13 to i8*
%22 = bitcast [9 x double]* %14 to i8*
%23 = fmul double %2, 5.000000e-01
%24 = getelementptr double, double* %5, i64 1
%25 = bitcast double* %24 to i8*
%26 = load double, double* %1
store double %26, double* %7
%27 = getelementptr inbounds double, double* %1, i64 3
%28 = load double, double* %27
%29 = getelementptr inbounds double, double* %7, i64 1
store double %28, double* %29
%30 = getelementptr inbounds double, double* %1, i64 6
%31 = load double, double* %30
%32 = getelementptr inbounds double, double* %7, i64 2
store double %31, double* %32
%33 = fdiv double %2, 6.000000e+00
%34 = icmp ugt i32 %3, 1
br i1 %34, label %35, label %277
35: ; preds = %8
%36 = icmp eq i32 %4, 0
%37 = getelementptr inbounds double, double* %6, i64 2
%38 = getelementptr inbounds double, double* %6, i64 3
%39 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 0
%40 = getelementptr inbounds [12 x double], [12 x double]* %15, i64 0, i64 0
%41 = getelementptr inbounds [9 x double], [9 x double]* %9, i64 0, i64 0
%42 = getelementptr inbounds [9 x double], [9 x double]* %12, i64 0, i64 0
%43 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 0
%44 = getelementptr inbounds [9 x double], [9 x double]* %13, i64 0, i64 0
%45 = getelementptr inbounds [9 x double], [9 x double]* %14, i64 0, i64 0
%46 = zext i32 %3 to i64
%47 = getelementptr inbounds double, double* %1, i64 2
%48 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 2
%49 = getelementptr inbounds [9 x double], [9 x double]* %9, i64 0, i64 2
%50 = getelementptr inbounds double, double* %1, i64 4
%51 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 4
%52 = getelementptr inbounds [9 x double], [9 x double]* %9, i64 0, i64 4
%53 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 6
%54 = getelementptr inbounds [9 x double], [9 x double]* %9, i64 0, i64 6
%55 = getelementptr inbounds double, double* %1, i64 8
%56 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 8
%57 = getelementptr inbounds [9 x double], [9 x double]* %9, i64 0, i64 8
%58 = getelementptr inbounds [9 x double], [9 x double]* %12, i64 0, i64 2
%59 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 2
%60 = getelementptr inbounds [9 x double], [9 x double]* %12, i64 0, i64 4
%61 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 4
%62 = getelementptr inbounds [9 x double], [9 x double]* %12, i64 0, i64 6
%63 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 6
%64 = getelementptr inbounds [9 x double], [9 x double]* %12, i64 0, i64 8
%65 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 8
%66 = getelementptr inbounds [9 x double], [9 x double]* %13, i64 0, i64 2
%67 = getelementptr inbounds [9 x double], [9 x double]* %13, i64 0, i64 4
%68 = getelementptr inbounds [9 x double], [9 x double]* %13, i64 0, i64 6
%69 = getelementptr inbounds [9 x double], [9 x double]* %13, i64 0, i64 8
%70 = getelementptr inbounds [9 x double], [9 x double]* %14, i64 0, i64 2
%71 = getelementptr inbounds [9 x double], [9 x double]* %14, i64 0, i64 4
%72 = getelementptr inbounds [9 x double], [9 x double]* %14, i64 0, i64 6
%73 = getelementptr inbounds [9 x double], [9 x double]* %14, i64 0, i64 8
%74 = bitcast double* %1 to <2 x double>*
%75 = bitcast [9 x double]* %11 to <2 x double>*
%76 = insertelement <2 x double> poison, double %23, i64 0
%77 = shufflevector <2 x double> %76, <2 x double> poison, <2 x i32> zeroinitializer
%78 = bitcast [9 x double]* %9 to <2 x double>*
%79 = bitcast double* %47 to <2 x double>*
%80 = bitcast double* %48 to <2 x double>*
%81 = bitcast double* %49 to <2 x double>*
%82 = bitcast double* %50 to <2 x double>*
%83 = bitcast double* %51 to <2 x double>*
%84 = bitcast double* %52 to <2 x double>*
%85 = bitcast double* %30 to <2 x double>*
%86 = bitcast double* %53 to <2 x double>*
%87 = bitcast double* %54 to <2 x double>*
%88 = bitcast double* %1 to <2 x double>*
%89 = bitcast [9 x double]* %12 to <2 x double>*
%90 = bitcast [9 x double]* %10 to <2 x double>*
%91 = bitcast double* %47 to <2 x double>*
%92 = bitcast double* %58 to <2 x double>*
%93 = bitcast double* %59 to <2 x double>*
%94 = bitcast double* %50 to <2 x double>*
%95 = bitcast double* %60 to <2 x double>*
%96 = bitcast double* %61 to <2 x double>*
%97 = bitcast double* %30 to <2 x double>*
%98 = bitcast double* %62 to <2 x double>*
%99 = bitcast double* %63 to <2 x double>*
%100 = bitcast double* %1 to <2 x double>*
%101 = bitcast [9 x double]* %13 to <2 x double>*
%102 = insertelement <2 x double> poison, double %2, i64 0
%103 = shufflevector <2 x double> %102, <2 x double> poison, <2 x i32> zeroinitializer
%104 = bitcast [9 x double]* %10 to <2 x double>*
%105 = bitcast double* %47 to <2 x double>*
%106 = bitcast double* %66 to <2 x double>*
%107 = bitcast double* %59 to <2 x double>*
%108 = bitcast double* %50 to <2 x double>*
%109 = bitcast double* %67 to <2 x double>*
%110 = bitcast double* %61 to <2 x double>*
%111 = bitcast double* %30 to <2 x double>*
%112 = bitcast double* %68 to <2 x double>*
%113 = bitcast double* %63 to <2 x double>*
%114 = bitcast [9 x double]* %11 to <2 x double>*
%115 = bitcast [9 x double]* %12 to <2 x double>*
%116 = bitcast [9 x double]* %13 to <2 x double>*
%117 = bitcast [9 x double]* %14 to <2 x double>*
%118 = bitcast double* %1 to <2 x double>*
%119 = insertelement <2 x double> poison, double %33, i64 0
%120 = shufflevector <2 x double> %119, <2 x double> poison, <2 x i32> zeroinitializer
%121 = bitcast double* %1 to <2 x double>*
%122 = bitcast double* %48 to <2 x double>*
%123 = bitcast double* %58 to <2 x double>*
%124 = bitcast double* %66 to <2 x double>*
%125 = bitcast double* %70 to <2 x double>*
%126 = bitcast double* %47 to <2 x double>*
%127 = bitcast double* %47 to <2 x double>*
%128 = bitcast double* %51 to <2 x double>*
%129 = bitcast double* %60 to <2 x double>*
%130 = bitcast double* %67 to <2 x double>*
%131 = bitcast double* %71 to <2 x double>*
%132 = bitcast double* %50 to <2 x double>*
%133 = bitcast double* %50 to <2 x double>*
%134 = bitcast double* %53 to <2 x double>*
%135 = bitcast double* %62 to <2 x double>*
%136 = bitcast double* %68 to <2 x double>*
%137 = bitcast double* %72 to <2 x double>*
%138 = bitcast double* %30 to <2 x double>*
%139 = bitcast double* %30 to <2 x double>*
br label %140
140: ; preds = %35, %147
%141 = phi i64 [ 1, %35 ], [ %162, %147 ]
%142 = phi i32 [ 0, %35 ], [ %149, %147 ]
br i1 %36, label %143, label %164
143: ; preds = %140
%144 = load double, double* %1
br label %147
145: ; preds = %164
%146 = extractelement <2 x double> %238, i64 0
br label %147
147: ; preds = %145, %143
%148 = phi double [ %144, %143 ], [ %146, %145 ]
%149 = phi i32 [ %142, %143 ], [ %224, %145 ]
%150 = trunc i64 %141 to i32
%151 = mul i32 %150, 3
%152 = zext i32 %151 to i64
%153 = getelementptr inbounds double, double* %7, i64 %152
store double %148, double* %153
%154 = load double, double* %27
%155 = add i32 %151, 1
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds double, double* %7, i64 %156
store double %154, double* %157
%158 = load double, double* %30
%159 = add i32 %151, 2
%160 = zext i32 %159 to i64
%161 = getelementptr inbounds double, double* %7, i64 %160
store double %158, double* %161
%162 = add nuw nsw i64 %141, 1
%163 = icmp eq i64 %162, %46
br i1 %163, label %277, label %140
164: ; preds = %140, %164
%165 = phi i32 [ %275, %164 ], [ 0, %140 ]
%166 = phi i32 [ %224, %164 ], [ %142, %140 ]
%167 = zext i32 %166 to i64
%168 = getelementptr inbounds double, double* %0, i64 %167
%169 = load double, double* %168
store double %169, double* %37
%170 = load double, double* %168
store double %170, double* %38
%171 = call i32 @derivs_three(double* %1, double* %39, double* %40, double* %6)
%172 = load <2 x double>, <2 x double>* %74
%173 = load <2 x double>, <2 x double>* %75
%174 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %173, <2 x double> %77, <2 x double> %172)
store <2 x double> %174, <2 x double>* %78
%175 = load <2 x double>, <2 x double>* %79
%176 = load <2 x double>, <2 x double>* %80
%177 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %176, <2 x double> %77, <2 x double> %175)
store <2 x double> %177, <2 x double>* %81
%178 = load <2 x double>, <2 x double>* %82
%179 = load <2 x double>, <2 x double>* %83
%180 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %179, <2 x double> %77, <2 x double> %178)
store <2 x double> %180, <2 x double>* %84
%181 = load <2 x double>, <2 x double>* %85
%182 = load <2 x double>, <2 x double>* %86
%183 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %182, <2 x double> %77, <2 x double> %181)
store <2 x double> %183, <2 x double>* %87
%184 = load double, double* %55
%185 = load double, double* %56
%186 = call double @llvm.fmuladd.f64(double %185, double %23, double %184)
store double %186, double* %57
%187 = add i32 %166, 1
%188 = zext i32 %187 to i64
%189 = getelementptr inbounds double, double* %0, i64 %188
%190 = load double, double* %189
store double %190, double* %37
%191 = load double, double* %189
store double %191, double* %38
%192 = call i32 @derivs_three(double* %41, double* %42, double* %40, double* %6)
%193 = load <2 x double>, <2 x double>* %88
%194 = load <2 x double>, <2 x double>* %89
%195 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %194, <2 x double> %77, <2 x double> %193)
store <2 x double> %195, <2 x double>* %90
%196 = load <2 x double>, <2 x double>* %91
%197 = load <2 x double>, <2 x double>* %92
%198 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %197, <2 x double> %77, <2 x double> %196)
store <2 x double> %198, <2 x double>* %93
%199 = load <2 x double>, <2 x double>* %94
%200 = load <2 x double>, <2 x double>* %95
%201 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %200, <2 x double> %77, <2 x double> %199)
store <2 x double> %201, <2 x double>* %96
%202 = load <2 x double>, <2 x double>* %97
%203 = load <2 x double>, <2 x double>* %98
%204 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %203, <2 x double> %77, <2 x double> %202)
store <2 x double> %204, <2 x double>* %99
%205 = load double, double* %55
%206 = load double, double* %64
%207 = call double @llvm.fmuladd.f64(double %206, double %23, double %205)
store double %207, double* %65
%208 = call i32 @derivs_three(double* %43, double* %44, double* %40, double* %6)
%209 = load <2 x double>, <2 x double>* %100
%210 = load <2 x double>, <2 x double>* %101
%211 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %210, <2 x double> %103, <2 x double> %209)
store <2 x double> %211, <2 x double>* %104
%212 = load <2 x double>, <2 x double>* %105
%213 = load <2 x double>, <2 x double>* %106
%214 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %213, <2 x double> %103, <2 x double> %212)
store <2 x double> %214, <2 x double>* %107
%215 = load <2 x double>, <2 x double>* %108
%216 = load <2 x double>, <2 x double>* %109
%217 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %216, <2 x double> %103, <2 x double> %215)
store <2 x double> %217, <2 x double>* %110
%218 = load <2 x double>, <2 x double>* %111
%219 = load <2 x double>, <2 x double>* %112
%220 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %219, <2 x double> %103, <2 x double> %218)
store <2 x double> %220, <2 x double>* %113
%221 = load double, double* %55
%222 = load double, double* %69
%223 = call double @llvm.fmuladd.f64(double %222, double %2, double %221)
store double %223, double* %65
%224 = add i32 %166, 2
%225 = zext i32 %224 to i64
%226 = getelementptr inbounds double, double* %0, i64 %225
%227 = load double, double* %226
store double %227, double* %37
%228 = load double, double* %226
store double %228, double* %38
%229 = call i32 @derivs_three(double* %43, double* %45, double* %40, double* %6)
%230 = load <2 x double>, <2 x double>* %114
%231 = load <2 x double>, <2 x double>* %115
%232 = load <2 x double>, <2 x double>* %116
%233 = fadd <2 x double> %231, %232
%234 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %233, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %230)
%235 = load <2 x double>, <2 x double>* %117
%236 = fadd <2 x double> %235, %234
%237 = load <2 x double>, <2 x double>* %118
%238 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %120, <2 x double> %236, <2 x double> %237)
store <2 x double> %238, <2 x double>* %121
%239 = load <2 x double>, <2 x double>* %122
%240 = load <2 x double>, <2 x double>* %123
%241 = load <2 x double>, <2 x double>* %124
%242 = fadd <2 x double> %240, %241
%243 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %242, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %239)
%244 = load <2 x double>, <2 x double>* %125
%245 = fadd <2 x double> %244, %243
%246 = load <2 x double>, <2 x double>* %126
%247 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %120, <2 x double> %245, <2 x double> %246)
store <2 x double> %247, <2 x double>* %127
%248 = load <2 x double>, <2 x double>* %128
%249 = load <2 x double>, <2 x double>* %129
%250 = load <2 x double>, <2 x double>* %130
%251 = fadd <2 x double> %249, %250
%252 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %251, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %248)
%253 = load <2 x double>, <2 x double>* %131
%254 = fadd <2 x double> %253, %252
%255 = load <2 x double>, <2 x double>* %132
%256 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %120, <2 x double> %254, <2 x double> %255)
store <2 x double> %256, <2 x double>* %133
%257 = load <2 x double>, <2 x double>* %134
%258 = load <2 x double>, <2 x double>* %135
%259 = load <2 x double>, <2 x double>* %136
%260 = fadd <2 x double> %258, %259
%261 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %260, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %257)
%262 = load <2 x double>, <2 x double>* %137
%263 = fadd <2 x double> %262, %261
%264 = load <2 x double>, <2 x double>* %138
%265 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %120, <2 x double> %263, <2 x double> %264)
store <2 x double> %265, <2 x double>* %139
%266 = load double, double* %56
%267 = load double, double* %64
%268 = load double, double* %69
%269 = fadd double %267, %268
%270 = call double @llvm.fmuladd.f64(double %269, double 2.000000e+00, double %266)
%271 = load double, double* %73
%272 = fadd double %271, %270
%273 = load double, double* %55
%274 = call double @llvm.fmuladd.f64(double %33, double %272, double %273)
store double %274, double* %55
%275 = add nuw i32 %165, 1
%276 = icmp eq i32 %275, %4
br i1 %276, label %145, label %164
277: ; preds = %147, %8
ret void
}