void masterflat(int nr, int nc, int nh, double (*cube)[nc][nh], double *times,
                double (*intercept)[nc]) {
  int i, j, k;
  double mx2, mx, my, mxy, msigy, msigxy, sigy;
  for (i = 0; i < nr; i++) {
    for (j = 0; j < nc; j++) {
      mx2 = mx = my = mxy = 0;
      for (k = 0; k < nh; k++) {
        mx2 += (times[k] * times[k]);
        my += cube[i][j][k];
        mx += (times[k]);
        mxy += (cube[i][j][k] * times[k]);
      }
      intercept[i][j] = ((mx2 * my) - (mx * mxy)) / ((nh * mx2) - (mx * mx));
    }
  }
}


x86 assembly (clang, -O0):
<masterflat>:
push   %rbp
mov    %rsp,%rbp
push   %rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x8(%rbp),%eax
mov    %rax,-0x88(%rbp)
mov    -0xc(%rbp),%eax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%eax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    131c <masterflat+0x21c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1309 <masterflat+0x209>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1271 <masterflat+0x171>
mov    -0x80(%rbp),%rdx
mov    -0x88(%rbp),%rsi
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rsi,%rdi
imul   %rdx,%rdi
imul   %rdi,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rsi
imul   %rsi,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    117f <masterflat+0x7f>
mov    -0x78(%rbp),%rdx
movsd  -0x40(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
mulsd  -0x48(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    114c <masterflat+0x4c>
jmp    130e <masterflat+0x20e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1139 <masterflat+0x39>
add    $0x8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<masterflat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9,-0x10(%rsp)
mov    %rcx,-0x20(%rsp)
mov    %esi,-0x24(%rsp)
test   %edi,%edi
jle    12ec <masterflat+0x1ec>
mov    -0x24(%rsp),%eax
mov    %edx,%r10d
mov    %r10,%rsi
imul   %rax,%rsi
cvtsi2sd %edx,%xmm8
mov    %edi,%ecx
mov    %rcx,-0x8(%rsp)
mov    %r10d,%ebx
and    $0xfffffffe,%ebx
mov    -0x20(%rsp),%rcx
lea    0x8(%rcx),%r9
mov    %rsi,-0x18(%rsp)
lea    0x0(,%rsi,8),%r15
lea    0x0(,%r10,8),%rdi
xor    %r13d,%r13d
jmp    1182 <masterflat+0x82>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r13
add    %r15,%r9
cmp    -0x8(%rsp),%r13
je     12ec <masterflat+0x1ec>
cmpl   $0x0,-0x24(%rsp)
jle    1170 <masterflat+0x70>
mov    -0x18(%rsp),%rcx
imul   %r13,%rcx
mov    -0x20(%rsp),%rsi
lea    (%rsi,%rcx,8),%rbp
mov    %r13,%rcx
imul   %rax,%rcx
mov    -0x10(%rsp),%rsi
lea    (%rsi,%rcx,8),%r11
mov    %r9,%r12
xor    %esi,%esi
jmp    1207 <masterflat+0x107>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm3,%xmm3
xorpd  %xmm2,%xmm2
xorpd  %xmm1,%xmm1
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm3,%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
mulsd  %xmm8,%xmm3
subsd  %xmm2,%xmm3
divsd  %xmm3,%xmm1
movsd  %xmm1,(%r11,%rsi,8)
add    $0x1,%rsi
add    %rdi,%r12
cmp    %rax,%rsi
je     1170 <masterflat+0x70>
test   %edx,%edx
jle    11c0 <masterflat+0xc0>
xorpd  %xmm4,%xmm4
xorpd  %xmm1,%xmm1
cmp    $0x1,%edx
jne    1230 <masterflat+0x130>
xor    %r14d,%r14d
xorpd  %xmm2,%xmm2
test   $0x1,%r10b
je     11cc <masterflat+0xcc>
jmp    12ad <masterflat+0x1ad>
nopw   0x0(%rax,%rax,1)
xor    %r14d,%r14d
xorpd  %xmm2,%xmm2
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r12,%r14,8),%xmm6
movsd  (%r12,%r14,8),%xmm7
addsd  %xmm6,%xmm1
movsd  (%r8,%r14,8),%xmm5
movsd  0x8(%r8,%r14,8),%xmm3
addsd  %xmm5,%xmm2
movapd %xmm5,%xmm0
unpcklpd %xmm6,%xmm0
unpcklpd %xmm5,%xmm5
mulpd  %xmm0,%xmm5
addpd  %xmm4,%xmm5
addsd  %xmm7,%xmm1
addsd  %xmm3,%xmm2
movapd %xmm3,%xmm0
unpcklpd %xmm7,%xmm0
unpcklpd %xmm3,%xmm3
mulpd  %xmm0,%xmm3
movapd %xmm3,%xmm4
addpd  %xmm5,%xmm4
add    $0x2,%r14
cmp    %r14,%rbx
jne    1240 <masterflat+0x140>
addpd  %xmm5,%xmm3
test   $0x1,%r10b
je     11cc <masterflat+0xcc>
mov    %rsi,%rcx
imul   %r10,%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
movsd  (%r8,%r14,8),%xmm3
movsd  (%rcx,%r14,8),%xmm0
addsd  %xmm0,%xmm1
addsd  %xmm3,%xmm2
movapd %xmm3,%xmm5
unpcklpd %xmm0,%xmm5
unpcklpd %xmm3,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm4,%xmm3
jmp    11cc <masterflat+0xcc>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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