#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 pow(double, double const);
void conservativeSatRichardsBrooksCoreyBurdineHomEvaluate(
    const int nPoints, const int nSpace, const double rho,
    const double *gravity, const double lambda, const double pd,
    const double thetaR, const double thetaSR, const double KWs, double *u,
    double *mass, double *dmass, double *f, double *df, double *a, double *da,
    double *phi, double *dphi) {
  int k, I;
  const int nSpace2 = nSpace * nSpace;
  register double psiC = 0.0, pcBar, sBar, DsBar_DpsiC = 0.0, thetaW,
                  DthetaW_DpsiC = 0.0, KW, DKW_DpsiC, rho2 = rho * rho,
                  thetaS = thetaR + thetaSR;
  for (k = 0; k < nPoints; k++) {
    sBar = u[k];
    thetaW = thetaS * sBar;
    if (u[k] < 1.0) {
      psiC = pow(sBar, -1 / lambda) * pd;
      pcBar = psiC / pd;
      sBar = pow(pcBar, -lambda);
      DsBar_DpsiC = -lambda * sBar / (pcBar * pd);
      KW = KWs * pow(sBar, (2 + 3 * lambda) / lambda);
      DKW_DpsiC = KWs * ((2 + 3 * lambda) / lambda *
                         pow(sBar, 2 / lambda * (1 + lambda)) * DsBar_DpsiC);
      thetaW = thetaSR * sBar + thetaR;
      DthetaW_DpsiC = thetaSR * DsBar_DpsiC;
    } else {
      KW = KWs;
      DKW_DpsiC = 0.0;
    }
    mass[k] = rho * thetaW;
    dmass[k] = -rho * DthetaW_DpsiC;
    phi[k] = -psiC;
    dphi[k] = -1.0 / DsBar_DpsiC;
    for (I = 0; I < nSpace; I++) {
      f[k * nSpace + I] = rho2 * KW * gravity[I];
      df[k * nSpace + I] = rho2 * DKW_DpsiC * gravity[I] / DsBar_DpsiC;
      a[k * nSpace2 + I * nSpace + I] = rho * KW;
      da[k * nSpace2 + I * nSpace + I] = rho * DKW_DpsiC / DsBar_DpsiC;
    }
  }
}


x86 assembly (clang, -O0):
<conservativeSatRichardsBrooksCoreyBurdineHomEvaluate>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
movsd  %xmm2,-0x28(%rbp)
movsd  %xmm3,-0x30(%rbp)
movsd  %xmm4,-0x38(%rbp)
movsd  %xmm5,-0x40(%rbp)
mov    %rcx,-0x48(%rbp)
mov    %r8,-0x50(%rbp)
mov    %r9,-0x58(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x64(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1562 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x452>
mov    -0x48(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  0xe03(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    13b7 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x2a7>
movsd  -0x80(%rbp),%xmm0
movsd  0xe03(%rip),%xmm1
divsd  -0x20(%rbp),%xmm1
call   1030 <pow@plt>
cvtsi2sd %eax,%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
call   1030 <pow@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x20(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
mulsd  -0x28(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  0xd4f(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xd3b(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  -0x20(%rbp),%xmm1
call   1030 <pow@plt>
movsd  -0xd0(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  0xd03(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xcef(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  0xcd1(%rip),%xmm1
divsd  -0x20(%rbp),%xmm1
movsd  0xcbc(%rip),%xmm2
addsd  -0x20(%rbp),%xmm2
mulsd  %xmm2,%xmm1
call   1030 <pow@plt>
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0xc0(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
jmp    13cf <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x2bf>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xbcd(%rip),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    154f <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x43f>
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x64(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
divsd  -0x88(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x64(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1467 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x357>
jmp    1554 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x444>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11ba <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0xaa>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<conservativeSatRichardsBrooksCoreyBurdineHomEvaluate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r9,0x88(%rsp)
movsd  %xmm5,0x10(%rsp)
movsd  %xmm4,0x30(%rsp)
movsd  %xmm3,0x28(%rsp)
movsd  %xmm2,0x40(%rsp)
test   %edi,%edi
jle    14d1 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x3c1>
mov    %rdx,%rbx
movapd %xmm0,%xmm7
mov    0x158(%rsp),%r9
mov    0x150(%rsp),%r11
mov    0x148(%rsp),%rax
mov    0x138(%rsp),%r15
mov    0x130(%rsp),%r12
mulsd  %xmm7,%xmm0
movapd %xmm0,0xd0(%rsp)
movsd  0x28(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0xe60(%rip),%xmm11
movapd %xmm11,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x50(%rsp)
movapd 0xe68(%rip),%xmm8
movapd %xmm1,%xmm2
movsd  0xe44(%rip),%xmm3
mulsd  %xmm1,%xmm3
movsd  0xe40(%rip),%xmm0
addsd  %xmm0,%xmm3
divsd  %xmm1,%xmm3
movsd  %xmm3,0x38(%rsp)
divsd  %xmm1,%xmm0
addsd  0xe2e(%rip),%xmm1
xorpd  %xmm8,%xmm2
movapd %xmm2,0x90(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0xc0(%rsp)
xorpd  %xmm7,%xmm8
movslq %esi,%rdx
mov    %edi,%edi
mov    %rdi,0x78(%rsp)
mov    %rax,%rdi
mov    %edx,%ebp
mov    %edx,%eax
imul   %edx,%eax
mov    %eax,0x24(%rsp)
lea    0x1(%rdx),%r13d
shl    $0x3,%rdx
mov    %rdx,0x80(%rsp)
xorpd  %xmm6,%xmm6
xor    %eax,%eax
mov    %rax,0x18(%rsp)
movsd  0xdd2(%rip),%xmm12
movaps 0xdd2(%rip),%xmm9
xor    %r14d,%r14d
xorpd  %xmm13,%xmm13
xorps  %xmm10,%xmm10
mov    %r8,0x68(%rsp)
mov    %rcx,0x60(%rsp)
movapd %xmm7,0xb0(%rsp)
mov    %esi,0x20(%rsp)
movapd %xmm8,0xa0(%rsp)
jmp    12ab <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x19b>
nopl   (%rax)
add    $0x1,%r14
mov    0x18(%rsp),%rax
add    0x24(%rsp),%eax
mov    %rax,0x18(%rsp)
mov    0x80(%rsp),%rax
add    %rax,%r12
add    %rax,%r15
cmp    0x78(%rsp),%r14
je     14d1 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x3c1>
movsd  (%rcx,%r14,8),%xmm0
ucomisd %xmm0,%xmm12
jbe    1400 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x2f0>
movsd  0x50(%rsp),%xmm1
call   1030 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x40(%rsp),%xmm1
mulsd  %xmm1,%xmm0
movapd %xmm0,0xe0(%rsp)
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
movaps 0x90(%rsp),%xmm1
call   1030 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x48(%rsp)
movapd 0x90(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x8(%rsp),%xmm2
mulsd  0x40(%rsp),%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x38(%rsp),%xmm1
call   1030 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0x48(%rsp),%xmm0
movaps 0xc0(%rsp),%xmm1
call   1030 <pow@plt>
movsd  0x48(%rsp),%xmm0
movsd  0x70(%rsp),%xmm5
movsd  0x8(%rsp),%xmm13
movaps 0xe0(%rsp),%xmm10
movaps 0xca3(%rip),%xmm9
movsd  0xc92(%rip),%xmm12
movapd 0xa0(%rsp),%xmm8
movsd  0xc67(%rip),%xmm11
mov    0x148(%rsp),%rdi
mov    0x150(%rsp),%r11
mov    0x158(%rsp),%r9
mov    0x20(%rsp),%esi
movapd 0xb0(%rsp),%xmm7
mov    0x60(%rsp),%rcx
mov    0x68(%rsp),%r8
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  0x38(%rsp),%xmm1
mulsd  %xmm13,%xmm1
mulsd  0x10(%rsp),%xmm1
movsd  0x30(%rsp),%xmm2
mulsd  %xmm2,%xmm0
addsd  0x28(%rsp),%xmm0
movapd %xmm13,%xmm6
mulsd  %xmm2,%xmm6
jmp    1410 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x300>
nopl   0x0(%rax,%rax,1)
mulsd  0x58(%rsp),%xmm0
xorpd  %xmm1,%xmm1
movsd  0x10(%rsp),%xmm5
mulsd  %xmm7,%xmm0
movsd  %xmm0,(%r8,%r14,8)
movapd %xmm6,%xmm2
mulsd  %xmm8,%xmm2
mov    0x88(%rsp),%rax
movsd  %xmm2,(%rax,%r14,8)
movaps %xmm10,%xmm2
xorps  %xmm9,%xmm2
movlps %xmm2,(%r11,%r14,8)
movapd %xmm11,%xmm2
divsd  %xmm13,%xmm2
movsd  %xmm2,(%r9,%r14,8)
test   %esi,%esi
mov    0x140(%rsp),%r10
jle    1280 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x170>
movapd 0xd0(%rsp),%xmm3
movapd %xmm3,%xmm2
mulsd  %xmm5,%xmm2
mulsd  %xmm1,%xmm3
mulsd  %xmm7,%xmm5
mulsd  %xmm7,%xmm1
divsd  %xmm13,%xmm1
mov    0x18(%rsp),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm4
mulsd  %xmm2,%xmm4
movsd  %xmm4,(%r12,%rdx,8)
movsd  (%rbx,%rdx,8),%xmm4
mulsd  %xmm3,%xmm4
divsd  %xmm13,%xmm4
movsd  %xmm4,(%r15,%rdx,8)
cltq
movsd  %xmm5,(%r10,%rax,8)
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%rdx
add    %r13d,%eax
cmp    %rdx,%rbp
jne    1490 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x380>
jmp    1280 <conservativeSatRichardsBrooksCoreyBurdineHomEvaluate+0x170>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @conservativeSatRichardsBrooksCoreyBurdineHomEvaluate(i32 %0, i32 %1, double %2, double* nocapture %3, double %4, double %5, double %6, double %7, double %8, double* nocapture %9, double* nocapture writeonly %10, double* nocapture writeonly %11, double* nocapture writeonly %12, double* nocapture writeonly %13, double* nocapture writeonly %14, double* nocapture writeonly %15, double* nocapture writeonly %16, double* nocapture writeonly %17) {
%19 = fmul double %2, %2
%20 = fadd double %6, %7
%21 = icmp sgt i32 %0, 0
br i1 %21, label %22, label %113
22: ; preds = %18
%23 = fdiv double -1.000000e+00, %4
%24 = fneg double %4
%25 = tail call double @llvm.fmuladd.f64(double %4, double 3.000000e+00, double 2.000000e+00)
%26 = fdiv double %25, %4
%27 = fdiv double 2.000000e+00, %4
%28 = fadd double %4, 1.000000e+00
%29 = fmul double %27, %28
%30 = fneg double %2
%31 = icmp sgt i32 %1, 0
%32 = sext i32 %1 to i64
%33 = zext i32 %0 to i64
%34 = zext i32 %1 to i64
br label %35
35: ; preds = %22, %110
%36 = phi i64 [ 0, %22 ], [ %111, %110 ]
%37 = phi double [ 0.000000e+00, %22 ], [ %69, %110 ]
%38 = phi double [ 0.000000e+00, %22 ], [ %67, %110 ]
%39 = phi double [ 0.000000e+00, %22 ], [ %66, %110 ]
%40 = getelementptr inbounds double, double* %9, i64 %36
%41 = load double, double* %40
%42 = fcmp olt double %41, 1.000000e+00
br i1 %42, label %43, label %63
43: ; preds = %35
%44 = tail call i32 @pow(double %41, double %23)
%45 = sitofp i32 %44 to double
%46 = fmul double %45, %5
%47 = fdiv double %46, %5
%48 = tail call i32 @pow(double %47, double %24)
%49 = sitofp i32 %48 to double
%50 = fmul double %24, %49
%51 = fmul double %47, %5
%52 = fdiv double %50, %51
%53 = tail call i32 @pow(double %49, double %26)
%54 = sitofp i32 %53 to double
%55 = fmul double %54, %8
%56 = tail call i32 @pow(double %49, double %29)
%57 = sitofp i32 %56 to double
%58 = fmul double %26, %57
%59 = fmul double %58, %52
%60 = fmul double %59, %8
%61 = tail call double @llvm.fmuladd.f64(double %7, double %49, double %6)
%62 = fmul double %52, %7
br label %65
63: ; preds = %35
%64 = fmul double %20, %41
br label %65
65: ; preds = %63, %43
%66 = phi double [ %46, %43 ], [ %39, %63 ]
%67 = phi double [ %52, %43 ], [ %38, %63 ]
%68 = phi double [ %61, %43 ], [ %64, %63 ]
%69 = phi double [ %62, %43 ], [ %37, %63 ]
%70 = phi double [ %55, %43 ], [ %8, %63 ]
%71 = phi double [ %60, %43 ], [ 0.000000e+00, %63 ]
%72 = fmul double %68, %2
%73 = getelementptr inbounds double, double* %10, i64 %36
store double %72, double* %73
%74 = fmul double %69, %30
%75 = getelementptr inbounds double, double* %11, i64 %36
store double %74, double* %75
%76 = fneg double %66
%77 = getelementptr inbounds double, double* %16, i64 %36
store double %76, double* %77
%78 = fdiv double -1.000000e+00, %67
%79 = getelementptr inbounds double, double* %17, i64 %36
store double %78, double* %79
br i1 %31, label %80, label %110
80: ; preds = %65
%81 = fmul double %19, %70
%82 = mul nsw i64 %36, %32
%83 = fmul double %19, %71
%84 = fmul double %70, %2
%85 = trunc i64 %36 to i32
%86 = mul i32 %85, %1
%87 = fmul double %71, %2
%88 = fdiv double %87, %67
br label %89
89: ; preds = %80, %89
%90 = phi i64 [ 0, %80 ], [ %108, %89 ]
%91 = getelementptr inbounds double, double* %3, i64 %90
%92 = load double, double* %91
%93 = fmul double %81, %92
%94 = add nsw i64 %90, %82
%95 = getelementptr inbounds double, double* %12, i64 %94
store double %93, double* %95
%96 = load double, double* %91
%97 = fmul double %83, %96
%98 = fdiv double %97, %67
%99 = getelementptr inbounds double, double* %13, i64 %94
store double %98, double* %99
%100 = trunc i64 %90 to i32
%101 = add i32 %86, %100
%102 = mul i32 %101, %1
%103 = trunc i64 %90 to i32
%104 = add i32 %102, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %14, i64 %105
store double %84, double* %106
%107 = getelementptr inbounds double, double* %15, i64 %105
store double %88, double* %107
%108 = add nuw nsw i64 %90, 1
%109 = icmp eq i64 %108, %34
br i1 %109, label %110, label %89
110: ; preds = %89, %65
%111 = add nuw nsw i64 %36, 1
%112 = icmp eq i64 %111, %33
br i1 %112, label %113, label %35
113: ; preds = %110, %18
ret void
}