#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 */
double const boltzmann(double, double const, int);
int /*<<< orphan*/ derivs_one(double const *, double *, double const *);
void derivs_four(const double *y, double *dxdt, const double *p,
                 const double *kij) {
  int i;
  double bm_factor[4], V[4];
  for (i = 0; i < 4; i++) {
    V[i] = y[i * 3];
    derivs_one(y + i * 3, dxdt + i * 3, p);
    bm_factor[i] = boltzmann(V[i], p[11], 1000.) / p[6];
  }
  dxdt[0] += (-0.0625 - V[0]) * (kij[0] * bm_factor[1] + kij[1] * bm_factor[2] +
                                 kij[2] * bm_factor[3]);
  dxdt[3] += (-0.0625 - V[1]) * (kij[3] * bm_factor[0] + kij[4] * bm_factor[2] +
                                 kij[5] * bm_factor[3]);
  dxdt[2 * 3] +=
      (-0.0625 - V[2]) *
      (kij[6] * bm_factor[0] + kij[7] * bm_factor[1] + kij[8] * bm_factor[3]);
  dxdt[3 * 3] +=
      (-0.0625 - V[3]) *
      (kij[9] * bm_factor[0] + kij[10] * bm_factor[1] + kij[11] * bm_factor[2]);
  dxdt[0] += (kij[12] * (V[1] - V[0]) + kij[13] * (V[2] - V[0]) +
              kij[14] * (V[3] - V[0])) /
             p[6];
  dxdt[3] += (kij[12] * (V[0] - V[1]) + kij[15] * (V[2] - V[1]) +
              kij[16] * (V[3] - V[1])) /
             p[6];
  dxdt[2 * 3] += (kij[13] * (V[0] - V[2]) + kij[15] * (V[1] - V[2]) +
                  kij[17] * (V[3] - V[2])) /
                 p[6];
  dxdt[3 * 3] += (kij[14] * (V[0] - V[3]) + kij[16] * (V[1] - V[3]) +
                  kij[17] * (V[2] - V[3])) /
                 p[6];
}


x86 assembly (clang, -O0):
<derivs_four>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    11cc <derivs_four+0xac>
mov    -0x8(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x24(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x8(%rbp),%rdi
imul   $0x3,-0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
imul   $0x3,-0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x18(%rbp),%rdx
call   1040 <derivs_one@plt>
movslq -0x24(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x58(%rax),%xmm1
mov    $0x3e8,%edi
call   1030 <boltzmann@plt>
mov    -0x18(%rbp),%rax
divsd  0x30(%rax),%xmm0
movslq -0x24(%rbp),%rax
movsd  %xmm0,-0x50(%rbp,%rax,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    113f <derivs_four+0x1f>
movsd  0xe2c(%rip),%xmm0
subsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x48(%rbp),%xmm3
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  -0x40(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0x38(%rbp),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  0xdd2(%rip),%xmm0
subsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm1
movsd  -0x50(%rbp),%xmm3
mov    -0x20(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  -0x40(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x28(%rax),%xmm2
movsd  -0x38(%rbp),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
movsd  0xd75(%rip),%xmm0
subsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x30(%rax),%xmm1
movsd  -0x50(%rbp),%xmm3
mov    -0x20(%rbp),%rax
movsd  0x38(%rax),%xmm2
mulsd  -0x48(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x40(%rax),%xmm2
movsd  -0x38(%rbp),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
movsd  0xd18(%rip),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x48(%rax),%xmm1
movsd  -0x50(%rbp),%xmm3
mov    -0x20(%rbp),%rax
movsd  0x50(%rax),%xmm2
mulsd  -0x48(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x58(%rax),%xmm2
movsd  -0x40(%rbp),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x48(%rax)
mov    -0x20(%rbp),%rax
movsd  0x60(%rax),%xmm1
movsd  -0x68(%rbp),%xmm2
subsd  -0x70(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x68(%rax),%xmm0
movsd  -0x60(%rbp),%xmm3
subsd  -0x70(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
subsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
divsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  0x60(%rax),%xmm1
movsd  -0x70(%rbp),%xmm2
subsd  -0x68(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x78(%rax),%xmm0
movsd  -0x60(%rbp),%xmm3
subsd  -0x68(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x80(%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
subsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
divsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x18(%rax),%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x20(%rbp),%rax
movsd  0x68(%rax),%xmm1
movsd  -0x70(%rbp),%xmm2
subsd  -0x60(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x78(%rax),%xmm0
movsd  -0x68(%rbp),%xmm3
subsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x88(%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
subsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
divsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x30(%rax),%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x20(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  -0x70(%rbp),%xmm2
subsd  -0x58(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x80(%rax),%xmm0
movsd  -0x68(%rbp),%xmm3
subsd  -0x58(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x88(%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
subsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
divsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x48(%rax),%xmm0
movsd  %xmm0,0x48(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<derivs_four>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,%r12
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%rbx
movsd  (%rdi),%xmm0
movsd  %xmm0,(%rsp)
call   1040 <derivs_one@plt>
movsd  0x58(%r15),%xmm1
movsd  (%rsp),%xmm0
mov    $0x3e8,%edi
call   1030 <boltzmann@plt>
divsd  0x30(%r15),%xmm0
movsd  %xmm0,0x30(%rsp)
lea    0x18(%rbx),%rdi
movsd  0x18(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x18(%r14),%rsi
mov    %r15,%rdx
call   1040 <derivs_one@plt>
movsd  0x58(%r15),%xmm1
movsd  0x8(%rsp),%xmm0
mov    $0x3e8,%edi
call   1030 <boltzmann@plt>
divsd  0x30(%r15),%xmm0
movsd  %xmm0,0x28(%rsp)
lea    0x30(%rbx),%rdi
movsd  0x30(%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
lea    0x30(%r14),%rsi
mov    %r15,%rdx
call   1040 <derivs_one@plt>
movsd  0x58(%r15),%xmm1
movsd  0x10(%rsp),%xmm0
mov    $0x3e8,%edi
call   1030 <boltzmann@plt>
divsd  0x30(%r15),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x48(%rbx),%xmm0
movsd  %xmm0,0x18(%rsp)
add    $0x48,%rbx
lea    0x48(%r14),%rsi
mov    %rbx,%rdi
mov    %r15,%rdx
call   1040 <derivs_one@plt>
movsd  0x58(%r15),%xmm1
movsd  0x18(%rsp),%xmm0
mov    $0x3e8,%edi
call   1030 <boltzmann@plt>
divsd  0x30(%r15),%xmm0
movsd  0xdde(%rip),%xmm3
movapd %xmm3,%xmm1
movsd  (%rsp),%xmm11
subsd  %xmm11,%xmm1
movsd  0x8(%r12),%xmm2
movsd  0x20(%rsp),%xmm10
mulsd  %xmm10,%xmm2
movsd  (%r12),%xmm4
movsd  0x28(%rsp),%xmm8
mulsd  %xmm8,%xmm4
addsd  %xmm2,%xmm4
movsd  0x10(%r12),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm4,%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r14),%xmm2
movsd  %xmm2,(%r14)
movapd %xmm3,%xmm4
movsd  0x8(%rsp),%xmm9
subsd  %xmm9,%xmm4
movsd  0x20(%r12),%xmm1
mulsd  %xmm10,%xmm1
movsd  0x18(%r12),%xmm5
movsd  0x30(%rsp),%xmm7
mulsd  %xmm7,%xmm5
addsd  %xmm1,%xmm5
movsd  0x28(%r12),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm5,%xmm1
mulsd  %xmm4,%xmm1
addsd  0x18(%r14),%xmm1
movsd  %xmm1,0x18(%r14)
movapd %xmm3,%xmm4
movsd  0x10(%rsp),%xmm12
subsd  %xmm12,%xmm4
movsd  0x38(%r12),%xmm5
mulsd  %xmm8,%xmm5
movsd  0x30(%r12),%xmm6
mulsd  %xmm7,%xmm6
addsd  %xmm5,%xmm6
mulsd  0x40(%r12),%xmm0
addsd  %xmm6,%xmm0
mulsd  %xmm4,%xmm0
addsd  0x30(%r14),%xmm0
movsd  %xmm0,0x30(%r14)
movapd %xmm8,%xmm5
mulsd  0x50(%r12),%xmm5
movapd %xmm7,%xmm4
mulsd  0x48(%r12),%xmm4
movsd  0x18(%rsp),%xmm8
subsd  %xmm8,%xmm3
addsd  %xmm5,%xmm4
movapd %xmm10,%xmm7
mulsd  0x58(%r12),%xmm7
addsd  %xmm4,%xmm7
mulsd  %xmm3,%xmm7
addsd  0x48(%r14),%xmm7
movsd  %xmm7,0x48(%r14)
movapd %xmm9,%xmm3
movapd %xmm9,%xmm10
subsd  %xmm11,%xmm3
movapd %xmm12,%xmm4
subsd  %xmm11,%xmm4
mulsd  0x68(%r12),%xmm4
mulsd  0x60(%r12),%xmm3
movapd %xmm8,%xmm5
subsd  %xmm11,%xmm5
mulsd  0x70(%r12),%xmm5
addsd  %xmm4,%xmm3
addsd  %xmm3,%xmm5
divsd  0x30(%r15),%xmm5
addsd  %xmm2,%xmm5
movsd  %xmm5,(%r14)
movapd %xmm11,%xmm2
movapd %xmm9,%xmm5
subsd  %xmm10,%xmm2
movapd %xmm12,%xmm3
subsd  %xmm10,%xmm3
mulsd  0x78(%r12),%xmm3
mulsd  0x60(%r12),%xmm2
movapd %xmm8,%xmm4
subsd  %xmm10,%xmm4
mulsd  0x80(%r12),%xmm4
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm4
divsd  0x30(%r15),%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,0x18(%r14)
movapd %xmm11,%xmm1
subsd  %xmm12,%xmm1
movapd %xmm10,%xmm2
subsd  %xmm12,%xmm2
mulsd  0x78(%r12),%xmm2
mulsd  0x68(%r12),%xmm1
addsd  %xmm2,%xmm1
movapd %xmm8,%xmm2
subsd  %xmm12,%xmm2
mulsd  0x88(%r12),%xmm2
addsd  %xmm1,%xmm2
divsd  0x30(%r15),%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x30(%r14)
subsd  %xmm8,%xmm5
mulsd  0x80(%r12),%xmm5
movapd %xmm11,%xmm0
subsd  %xmm8,%xmm0
mulsd  0x70(%r12),%xmm0
addsd  %xmm5,%xmm0
movapd %xmm12,%xmm1
subsd  %xmm8,%xmm1
mulsd  0x88(%r12),%xmm1
addsd  %xmm0,%xmm1
divsd  0x30(%r15),%xmm1
addsd  %xmm7,%xmm1
movsd  %xmm1,0x48(%r14)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @derivs_four(double* %0, double* %1, double* %2, double* nocapture %3) {
%5 = getelementptr inbounds double, double* %2, i64 11
%6 = getelementptr inbounds double, double* %2, i64 6
%7 = load double, double* %0
%8 = tail call i32 @derivs_one(double* %0, double* %1, double* %2)
%9 = load double, double* %5
%10 = tail call double @boltzmann(double %7, double %9, i32 1000)
%11 = load double, double* %6
%12 = fdiv double %10, %11
%13 = getelementptr inbounds double, double* %0, i64 3
%14 = load double, double* %13
%15 = getelementptr inbounds double, double* %1, i64 3
%16 = tail call i32 @derivs_one(double* %13, double* %15, double* %2)
%17 = load double, double* %5
%18 = tail call double @boltzmann(double %14, double %17, i32 1000)
%19 = load double, double* %6
%20 = fdiv double %18, %19
%21 = getelementptr inbounds double, double* %0, i64 6
%22 = load double, double* %21
%23 = getelementptr inbounds double, double* %1, i64 6
%24 = tail call i32 @derivs_one(double* %21, double* %23, double* %2)
%25 = load double, double* %5
%26 = tail call double @boltzmann(double %22, double %25, i32 1000)
%27 = load double, double* %6
%28 = fdiv double %26, %27
%29 = getelementptr inbounds double, double* %0, i64 9
%30 = load double, double* %29
%31 = getelementptr inbounds double, double* %1, i64 9
%32 = tail call i32 @derivs_one(double* %29, double* %31, double* %2)
%33 = load double, double* %5
%34 = tail call double @boltzmann(double %30, double %33, i32 1000)
%35 = load double, double* %6
%36 = fdiv double %34, %35
%37 = fsub double -6.250000e-02, %7
%38 = load double, double* %3
%39 = getelementptr inbounds double, double* %3, i64 1
%40 = load double, double* %39
%41 = fmul double %40, %28
%42 = tail call double @llvm.fmuladd.f64(double %38, double %20, double %41)
%43 = getelementptr inbounds double, double* %3, i64 2
%44 = load double, double* %43
%45 = tail call double @llvm.fmuladd.f64(double %44, double %36, double %42)
%46 = load double, double* %1
%47 = tail call double @llvm.fmuladd.f64(double %37, double %45, double %46)
store double %47, double* %1
%48 = fsub double -6.250000e-02, %14
%49 = getelementptr inbounds double, double* %3, i64 3
%50 = load double, double* %49
%51 = getelementptr inbounds double, double* %3, i64 4
%52 = load double, double* %51
%53 = fmul double %28, %52
%54 = tail call double @llvm.fmuladd.f64(double %50, double %12, double %53)
%55 = getelementptr inbounds double, double* %3, i64 5
%56 = load double, double* %55
%57 = tail call double @llvm.fmuladd.f64(double %56, double %36, double %54)
%58 = load double, double* %15
%59 = tail call double @llvm.fmuladd.f64(double %48, double %57, double %58)
store double %59, double* %15
%60 = fsub double -6.250000e-02, %22
%61 = getelementptr inbounds double, double* %3, i64 6
%62 = load double, double* %61
%63 = getelementptr inbounds double, double* %3, i64 7
%64 = load double, double* %63
%65 = fmul double %20, %64
%66 = tail call double @llvm.fmuladd.f64(double %62, double %12, double %65)
%67 = getelementptr inbounds double, double* %3, i64 8
%68 = load double, double* %67
%69 = tail call double @llvm.fmuladd.f64(double %68, double %36, double %66)
%70 = load double, double* %23
%71 = tail call double @llvm.fmuladd.f64(double %60, double %69, double %70)
store double %71, double* %23
%72 = fsub double -6.250000e-02, %30
%73 = getelementptr inbounds double, double* %3, i64 9
%74 = load double, double* %73
%75 = getelementptr inbounds double, double* %3, i64 10
%76 = load double, double* %75
%77 = fmul double %20, %76
%78 = tail call double @llvm.fmuladd.f64(double %74, double %12, double %77)
%79 = getelementptr inbounds double, double* %3, i64 11
%80 = load double, double* %79
%81 = tail call double @llvm.fmuladd.f64(double %80, double %28, double %78)
%82 = load double, double* %31
%83 = tail call double @llvm.fmuladd.f64(double %72, double %81, double %82)
store double %83, double* %31
%84 = getelementptr inbounds double, double* %3, i64 12
%85 = load double, double* %84
%86 = fsub double %14, %7
%87 = getelementptr inbounds double, double* %3, i64 13
%88 = load double, double* %87
%89 = fsub double %22, %7
%90 = fmul double %89, %88
%91 = tail call double @llvm.fmuladd.f64(double %85, double %86, double %90)
%92 = getelementptr inbounds double, double* %3, i64 14
%93 = load double, double* %92
%94 = fsub double %30, %7
%95 = tail call double @llvm.fmuladd.f64(double %93, double %94, double %91)
%96 = load double, double* %6
%97 = fdiv double %95, %96
%98 = fadd double %47, %97
store double %98, double* %1
%99 = load double, double* %84
%100 = fsub double %7, %14
%101 = getelementptr inbounds double, double* %3, i64 15
%102 = load double, double* %101
%103 = fsub double %22, %14
%104 = fmul double %103, %102
%105 = tail call double @llvm.fmuladd.f64(double %99, double %100, double %104)
%106 = getelementptr inbounds double, double* %3, i64 16
%107 = load double, double* %106
%108 = fsub double %30, %14
%109 = tail call double @llvm.fmuladd.f64(double %107, double %108, double %105)
%110 = load double, double* %6
%111 = fdiv double %109, %110
%112 = fadd double %59, %111
store double %112, double* %15
%113 = load double, double* %87
%114 = fsub double %7, %22
%115 = load double, double* %101
%116 = fsub double %14, %22
%117 = fmul double %116, %115
%118 = tail call double @llvm.fmuladd.f64(double %113, double %114, double %117)
%119 = getelementptr inbounds double, double* %3, i64 17
%120 = load double, double* %119
%121 = fsub double %30, %22
%122 = tail call double @llvm.fmuladd.f64(double %120, double %121, double %118)
%123 = load double, double* %6
%124 = fdiv double %122, %123
%125 = fadd double %71, %124
store double %125, double* %23
%126 = load double, double* %92
%127 = fsub double %7, %30
%128 = load double, double* %106
%129 = fsub double %14, %30
%130 = fmul double %129, %128
%131 = tail call double @llvm.fmuladd.f64(double %126, double %127, double %130)
%132 = load double, double* %119
%133 = fsub double %22, %30
%134 = tail call double @llvm.fmuladd.f64(double %132, double %133, double %131)
%135 = load double, double* %6
%136 = fdiv double %134, %135
%137 = fadd double %83, %136
store double %137, double* %31
ret void
}