#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 const *,
                                double const *);
void step_three_rk4(double *y, const double *params, const double *coupling,
                    const double dt, const unsigned stride) {
  unsigned i, j, k;
  double dt2, dt6;
  double y1[3 * 3], y2[3 * 3], k1[3 * 3], k2[3 * 3], k3[3 * 3], k4[3 * 3];
  dt2 = dt / 2.;
  dt6 = dt / 6.;
  for (j = 0; j < stride; j++) {
    derivs_three(y, k1, params, coupling);
    for (k = 0; k < 3 * 3; k++)
      y1[k] = y[k] + k1[k] * dt2;
    derivs_three(y1, k2, params, coupling);
    for (k = 0; k < 3 * 3; k++)
      y2[k] = y[k] + k2[k] * dt2;
    derivs_three(y2, k3, params, coupling);
    for (k = 0; k < 3 * 3; k++)
      y2[k] = y[k] + k3[k] * dt;
    derivs_three(y2, k4, params, coupling);
    for (k = 0; k < 3 * 3; k++)
      y[k] += dt6 * (k1[k] + 2. * (k2[k] + k3[k]) + k4[k]);
  }
}


x86 assembly (clang, -O0):
<step_three_rk4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x220,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0xecc(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0xeae(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    134f <step_three_rk4+0x23f>
mov    -0x8(%rbp),%rdi
lea    -0x130(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rcx
call   1030 <derivs_three@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x9,-0x30(%rbp)
jae    11d6 <step_three_rk4+0xc6>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%eax
movsd  -0x130(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%eax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    118d <step_three_rk4+0x7d>
lea    -0x90(%rbp),%rdi
lea    -0x180(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rcx
call   1030 <derivs_three@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x9,-0x30(%rbp)
jae    1241 <step_three_rk4+0x131>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%eax
movsd  -0x180(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%eax
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11f8 <step_three_rk4+0xe8>
lea    -0xe0(%rbp),%rdi
lea    -0x1d0(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rcx
call   1030 <derivs_three@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x9,-0x30(%rbp)
jae    12ac <step_three_rk4+0x19c>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%eax
movsd  -0x1d0(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x20(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%eax
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1263 <step_three_rk4+0x153>
lea    -0xe0(%rbp),%rdi
lea    -0x220(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rcx
call   1030 <derivs_three@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x9,-0x30(%rbp)
jae    133c <step_three_rk4+0x22c>
movsd  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%eax
movsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
mov    -0x30(%rbp),%eax
movsd  -0x180(%rbp,%rax,8),%xmm2
ff ff
mov    -0x30(%rbp),%eax
addsd  -0x1d0(%rbp,%rax,8),%xmm2
ff ff
addsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
mov    -0x30(%rbp),%eax
addsd  -0x220(%rbp,%rax,8),%xmm2
ff ff
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12ce <step_three_rk4+0x1be>
jmp    1341 <step_three_rk4+0x231>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1162 <step_three_rk4+0x52>
add    $0x220,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<step_three_rk4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
movapd %xmm0,(%rsp)
test   %ecx,%ecx
je     14e6 <step_three_rk4+0x3d6>
mov    %ecx,%ebp
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%rbx
movsd  0xebf(%rip),%xmm1
movapd (%rsp),%xmm0
mulsd  %xmm0,%xmm1
movapd %xmm0,%xmm2
divsd  0xeb2(%rip),%xmm2
movapd %xmm1,0x20(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,0x10(%rsp)
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x180(%rsp)
movapd %xmm2,0x190(%rsp)
unpcklpd %xmm2,%xmm2
movapd %xmm2,0x170(%rsp)
lea    0x120(%rsp),%r13
lea    0x1a0(%rsp),%r12
nopl   0x0(%rax)
mov    %rbx,%rdi
lea    0xd0(%rsp),%rsi
mov    %r15,%rdx
mov    %r14,%rcx
call   1030 <derivs_three@plt>
movupd (%rbx),%xmm0
movapd 0xd0(%rsp),%xmm1
movapd 0x10(%rsp),%xmm2
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x1f0(%rsp)
movupd 0x10(%rbx),%xmm0
movapd 0xe0(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x200(%rsp)
movupd 0x20(%rbx),%xmm0
movapd 0xf0(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x210(%rsp)
movupd 0x30(%rbx),%xmm0
movapd 0x100(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x220(%rsp)
movsd  0x110(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
addsd  0x40(%rbx),%xmm0
movsd  %xmm0,0x230(%rsp)
lea    0x1f0(%rsp),%rdi
lea    0x80(%rsp),%rsi
mov    %r15,%rdx
mov    %r14,%rcx
call   1030 <derivs_three@plt>
movupd (%rbx),%xmm0
movapd 0x80(%rsp),%xmm1
movapd 0x10(%rsp),%xmm2
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x120(%rsp)
movupd 0x10(%rbx),%xmm0
movapd 0x90(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x130(%rsp)
movupd 0x20(%rbx),%xmm0
movapd 0xa0(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x140(%rsp)
movupd 0x30(%rbx),%xmm0
movapd 0xb0(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x150(%rsp)
movsd  0xc0(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
addsd  0x40(%rbx),%xmm0
movsd  %xmm0,0x160(%rsp)
mov    %r13,%rdi
lea    0x30(%rsp),%rsi
mov    %r15,%rdx
mov    %r14,%rcx
call   1030 <derivs_three@plt>
movupd (%rbx),%xmm0
movapd 0x30(%rsp),%xmm1
movapd 0x180(%rsp),%xmm2
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x120(%rsp)
movupd 0x10(%rbx),%xmm0
movapd 0x40(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x130(%rsp)
movupd 0x20(%rbx),%xmm0
movapd 0x50(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x140(%rsp)
movupd 0x30(%rbx),%xmm0
movapd 0x60(%rsp),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x150(%rsp)
movsd  0x70(%rsp),%xmm0
mulsd  (%rsp),%xmm0
addsd  0x40(%rbx),%xmm0
movsd  %xmm0,0x160(%rsp)
mov    %r13,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %r14,%rcx
call   1030 <derivs_three@plt>
movapd 0x80(%rsp),%xmm0
addpd  0x30(%rsp),%xmm0
addpd  %xmm0,%xmm0
addpd  0xd0(%rsp),%xmm0
addpd  0x1a0(%rsp),%xmm0
movupd (%rbx),%xmm1
movapd 0x170(%rsp),%xmm3
mulpd  %xmm3,%xmm0
addpd  %xmm0,%xmm1
movupd 0x10(%rbx),%xmm0
movupd 0x20(%rbx),%xmm2
movupd %xmm1,(%rbx)
movapd 0x90(%rsp),%xmm1
addpd  0x40(%rsp),%xmm1
addpd  %xmm1,%xmm1
addpd  0xe0(%rsp),%xmm1
addpd  0x1b0(%rsp),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0x10(%rbx)
movapd 0xa0(%rsp),%xmm0
addpd  0x50(%rsp),%xmm0
addpd  %xmm0,%xmm0
addpd  0xf0(%rsp),%xmm0
addpd  0x1c0(%rsp),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,0x20(%rbx)
movapd 0xb0(%rsp),%xmm0
addpd  0x60(%rsp),%xmm0
addpd  %xmm0,%xmm0
addpd  0x100(%rsp),%xmm0
addpd  0x1d0(%rsp),%xmm0
movupd 0x30(%rbx),%xmm1
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,0x30(%rbx)
movsd  0xc0(%rsp),%xmm0
addsd  0x70(%rsp),%xmm0
addsd  %xmm0,%xmm0
addsd  0x110(%rsp),%xmm0
addsd  0x1e0(%rsp),%xmm0
mulsd  0x190(%rsp),%xmm0
addsd  0x40(%rbx),%xmm0
movsd  %xmm0,0x40(%rbx)
add    $0xffffffff,%ebp
jne    11a0 <step_three_rk4+0x90>
add    $0x238,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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