void linear_fit(float x[], float y[], int ndata, float *a, float *b) {
  int i;
  float t, sxoss, sx = 0.0F, sy = 0.0F, st2 = 0.0F, ss;
  *b = 0.0;
  for (i = 0; i < ndata; i++) {
    sx += x[i];
    sy += y[i];
  }
  ss = (float)ndata;
  sxoss = sx / ss;
  for (i = 0; i < ndata; i++) {
    t = x[i] - sxoss;
    st2 += t * t;
    *b += t * y[i];
  }
  *b /= st2;
  *a = (sy - sx * (*b)) / ss;
}


x86 assembly (clang, -O0):
<linear_fit>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1189 <linear_fit+0x89>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1141 <linear_fit+0x41>
cvtsi2ssl -0x14(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x38(%rbp),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    121c <linear_fit+0x11c>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a9 <linear_fit+0xa9>
movss  -0x40(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x3c(%rbp),%xmm1
movss  -0x38(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<linear_fit>:
push   %r14
push   %rbx
movl   $0x0,(%r8)
test   %edx,%edx
jle    112c <linear_fit+0x2c>
mov    %edx,%r10d
lea    -0x1(%r10),%r9
mov    %r10d,%r11d
and    $0x3,%r11d
cmp    $0x3,%r9
jae    1143 <linear_fit+0x43>
xorps  %xmm0,%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
jmp    1197 <linear_fit+0x97>
cvtsi2ss %edx,%xmm2
movss  0xec8(%rip),%xmm5
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
jmp    1279 <linear_fit+0x179>
mov    %r10d,%ebx
and    $0xfffffffc,%ebx
xorps  %xmm0,%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addss  (%rdi,%rax,4),%xmm1
addss  (%rsi,%rax,4),%xmm0
addss  0x4(%rdi,%rax,4),%xmm1
addss  0x4(%rsi,%rax,4),%xmm0
addss  0x8(%rdi,%rax,4),%xmm1
addss  0x8(%rsi,%rax,4),%xmm0
addss  0xc(%rdi,%rax,4),%xmm1
addss  0xc(%rsi,%rax,4),%xmm0
add    $0x4,%rax
cmp    %rax,%rbx
jne    1160 <linear_fit+0x60>
test   %r11,%r11
je     11c4 <linear_fit+0xc4>
lea    (%rsi,%rax,4),%r14
lea    (%rdi,%rax,4),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
addss  (%rax,%rbx,4),%xmm1
addss  (%r14,%rbx,4),%xmm0
add    $0x1,%rbx
cmp    %rbx,%r11
jne    11b0 <linear_fit+0xb0>
cvtsi2ss %edx,%xmm2
test   %edx,%edx
jle    1271 <linear_fit+0x171>
movaps %xmm1,%xmm4
divss  %xmm2,%xmm4
test   %r9,%r9
je     1292 <linear_fit+0x192>
mov    %r10d,%edx
and    $0xfffffffe,%edx
xorps  %xmm3,%xmm3
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rax,4),%xmm5
subss  %xmm4,%xmm5
movss  (%rsi,%rax,4),%xmm6
unpcklps %xmm5,%xmm6
shufps $0x0,%xmm5,%xmm5
mulps  %xmm6,%xmm5
addps  %xmm3,%xmm5
movss  %xmm5,(%r8)
movss  0x4(%rdi,%rax,4),%xmm3
subss  %xmm4,%xmm3
movss  0x4(%rsi,%rax,4),%xmm6
unpcklps %xmm3,%xmm6
shufps $0x0,%xmm3,%xmm3
mulps  %xmm6,%xmm3
addps  %xmm5,%xmm3
movss  %xmm3,(%r8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    11f0 <linear_fit+0xf0>
movaps %xmm3,%xmm5
test   $0x1,%r10b
je     1267 <linear_fit+0x167>
movss  (%rdi,%rax,4),%xmm5
subss  %xmm4,%xmm5
movss  (%rsi,%rax,4),%xmm4
unpcklps %xmm5,%xmm4
shufps $0x0,%xmm5,%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm3
movss  %xmm3,(%r8)
movaps %xmm3,%xmm5
shufps $0x55,%xmm3,%xmm3
divss  %xmm3,%xmm5
jmp    1279 <linear_fit+0x179>
movss  0xd87(%rip),%xmm5
movss  %xmm5,(%r8)
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm0
divss  %xmm2,%xmm0
movss  %xmm0,(%rcx)
pop    %rbx
pop    %r14
ret
xorps  %xmm3,%xmm3
xor    %eax,%eax
test   $0x1,%r10b
jne    1244 <linear_fit+0x144>
jmp    1267 <linear_fit+0x167>

LLVM IR (-O0):
define void @linear_fit(float* %0, float* %1, i32 %2, float* %3, float* %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca i32
%9 = alloca float*
%10 = alloca float*
%11 = alloca i32
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
store float* %0, float** %6
store float* %1, float** %7
store i32 %2, i32* %8
store float* %3, float** %9
store float* %4, float** %10
store float 0.000000e+00, float* %14
store float 0.000000e+00, float* %15
store float 0.000000e+00, float* %16
%18 = load float*, float** %10
store float 0.000000e+00, float* %18
store i32 0, i32* %11
br label %19
19: ; preds = %38, %5
%20 = load i32, i32* %11
%21 = load i32, i32* %8
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %41
23: ; preds = %19
%24 = load float*, float** %6
%25 = load i32, i32* %11
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds float, float* %24, i64 %26
%28 = load float, float* %27
%29 = load float, float* %14
%30 = fadd float %29, %28
store float %30, float* %14
%31 = load float*, float** %7
%32 = load i32, i32* %11
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds float, float* %31, i64 %33
%35 = load float, float* %34
%36 = load float, float* %15
%37 = fadd float %36, %35
store float %37, float* %15
br label %38
38: ; preds = %23
%39 = load i32, i32* %11
%40 = add nsw i32 %39, 1
store i32 %40, i32* %11
br label %19
41: ; preds = %19
%42 = load i32, i32* %8
%43 = sitofp i32 %42 to float
store float %43, float* %17
%44 = load float, float* %14
%45 = load float, float* %17
%46 = fdiv float %44, %45
store float %46, float* %13
store i32 0, i32* %11
br label %47
47: ; preds = %72, %41
%48 = load i32, i32* %11
%49 = load i32, i32* %8
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %75
51: ; preds = %47
%52 = load float*, float** %6
%53 = load i32, i32* %11
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %52, i64 %54
%56 = load float, float* %55
%57 = load float, float* %13
%58 = fsub float %56, %57
store float %58, float* %12
%59 = load float, float* %12
%60 = load float, float* %12
%61 = load float, float* %16
%62 = call float @llvm.fmuladd.f32(float %59, float %60, float %61)
store float %62, float* %16
%63 = load float, float* %12
%64 = load float*, float** %7
%65 = load i32, i32* %11
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %64, i64 %66
%68 = load float, float* %67
%69 = load float*, float** %10
%70 = load float, float* %69
%71 = call float @llvm.fmuladd.f32(float %63, float %68, float %70)
store float %71, float* %69
br label %72
72: ; preds = %51
%73 = load i32, i32* %11
%74 = add nsw i32 %73, 1
store i32 %74, i32* %11
br label %47
75: ; preds = %47
%76 = load float, float* %16
%77 = load float*, float** %10
%78 = load float, float* %77
%79 = fdiv float %78, %76
store float %79, float* %77
%80 = load float, float* %15
%81 = load float, float* %14
%82 = load float*, float** %10
%83 = load float, float* %82
%84 = fneg float %81
%85 = call float @llvm.fmuladd.f32(float %84, float %83, float %80)
%86 = load float, float* %17
%87 = fdiv float %85, %86
%88 = load float*, float** %9
store float %87, float* %88
ret void
}

LLVM IR (-O2):
define void @linear_fit(float* nocapture %0, float* nocapture %1, i32 %2, float* nocapture writeonly %3, float* nocapture %4) {
store float 0.000000e+00, float* %4
%6 = icmp sgt i32 %2, 0
br i1 %6, label %9, label %7
7: ; preds = %5
%8 = sitofp i32 %2 to float
br label %137
9: ; preds = %5
%10 = zext i32 %2 to i64
%11 = add nsw i64 %10, -1
%12 = and i64 %10, 3
%13 = icmp ult i64 %11, 3
br i1 %13, label %51, label %14
14: ; preds = %9
%15 = and i64 %10, 4294967292
br label %16
16: ; preds = %16, %14
%17 = phi i64 [ 0, %14 ], [ %48, %16 ]
%18 = phi float [ 0.000000e+00, %14 ], [ %47, %16 ]
%19 = phi float [ 0.000000e+00, %14 ], [ %44, %16 ]
%20 = phi i64 [ 0, %14 ], [ %49, %16 ]
%21 = getelementptr inbounds float, float* %0, i64 %17
%22 = load float, float* %21
%23 = fadd float %19, %22
%24 = getelementptr inbounds float, float* %1, i64 %17
%25 = load float, float* %24
%26 = fadd float %18, %25
%27 = or i64 %17, 1
%28 = getelementptr inbounds float, float* %0, i64 %27
%29 = load float, float* %28
%30 = fadd float %23, %29
%31 = getelementptr inbounds float, float* %1, i64 %27
%32 = load float, float* %31
%33 = fadd float %26, %32
%34 = or i64 %17, 2
%35 = getelementptr inbounds float, float* %0, i64 %34
%36 = load float, float* %35
%37 = fadd float %30, %36
%38 = getelementptr inbounds float, float* %1, i64 %34
%39 = load float, float* %38
%40 = fadd float %33, %39
%41 = or i64 %17, 3
%42 = getelementptr inbounds float, float* %0, i64 %41
%43 = load float, float* %42
%44 = fadd float %37, %43
%45 = getelementptr inbounds float, float* %1, i64 %41
%46 = load float, float* %45
%47 = fadd float %40, %46
%48 = add nuw nsw i64 %17, 4
%49 = add i64 %20, 4
%50 = icmp eq i64 %49, %15
br i1 %50, label %51, label %16
51: ; preds = %16, %9
%52 = phi float [ undef, %9 ], [ %44, %16 ]
%53 = phi float [ undef, %9 ], [ %47, %16 ]
%54 = phi i64 [ 0, %9 ], [ %48, %16 ]
%55 = phi float [ 0.000000e+00, %9 ], [ %47, %16 ]
%56 = phi float [ 0.000000e+00, %9 ], [ %44, %16 ]
%57 = icmp eq i64 %12, 0
br i1 %57, label %72, label %58
58: ; preds = %51, %58
%59 = phi i64 [ %69, %58 ], [ %54, %51 ]
%60 = phi float [ %68, %58 ], [ %55, %51 ]
%61 = phi float [ %65, %58 ], [ %56, %51 ]
%62 = phi i64 [ %70, %58 ], [ 0, %51 ]
%63 = getelementptr inbounds float, float* %0, i64 %59
%64 = load float, float* %63
%65 = fadd float %61, %64
%66 = getelementptr inbounds float, float* %1, i64 %59
%67 = load float, float* %66
%68 = fadd float %60, %67
%69 = add nuw nsw i64 %59, 1
%70 = add i64 %62, 1
%71 = icmp eq i64 %70, %12
br i1 %71, label %72, label %58
72: ; preds = %58, %51
%73 = phi float [ %52, %51 ], [ %65, %58 ]
%74 = phi float [ %53, %51 ], [ %68, %58 ]
%75 = sitofp i32 %2 to float
%76 = fdiv float %73, %75
br i1 %6, label %77, label %137
77: ; preds = %72
%78 = and i64 %10, 1
%79 = icmp eq i64 %11, 0
br i1 %79, label %114, label %80
80: ; preds = %77
%81 = and i64 %10, 4294967294
br label %82
82: ; preds = %82, %80
%83 = phi i64 [ 0, %80 ], [ %109, %82 ]
%84 = phi <2 x float> [ zeroinitializer, %80 ], [ %107, %82 ]
%85 = phi i64 [ 0, %80 ], [ %110, %82 ]
%86 = getelementptr inbounds float, float* %0, i64 %83
%87 = load float, float* %86
%88 = fsub float %87, %76
%89 = getelementptr inbounds float, float* %1, i64 %83
%90 = load float, float* %89
%91 = insertelement <2 x float> poison, float %88, i64 0
%92 = shufflevector <2 x float> %91, <2 x float> poison, <2 x i32> zeroinitializer
%93 = insertelement <2 x float> poison, float %90, i64 0
%94 = insertelement <2 x float> %93, float %88, i64 1
%95 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %92, <2 x float> %94, <2 x float> %84)
%96 = extractelement <2 x float> %95, i64 0
store float %96, float* %4
%97 = or i64 %83, 1
%98 = getelementptr inbounds float, float* %0, i64 %97
%99 = load float, float* %98
%100 = fsub float %99, %76
%101 = getelementptr inbounds float, float* %1, i64 %97
%102 = load float, float* %101
%103 = insertelement <2 x float> poison, float %100, i64 0
%104 = shufflevector <2 x float> %103, <2 x float> poison, <2 x i32> zeroinitializer
%105 = insertelement <2 x float> poison, float %102, i64 0
%106 = insertelement <2 x float> %105, float %100, i64 1
%107 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %104, <2 x float> %106, <2 x float> %95)
%108 = extractelement <2 x float> %107, i64 0
store float %108, float* %4
%109 = add nuw nsw i64 %83, 2
%110 = add i64 %85, 2
%111 = icmp eq i64 %110, %81
br i1 %111, label %112, label %82
112: ; preds = %82
%113 = extractelement <2 x float> %107, i64 0
br label %114
114: ; preds = %112, %77
%115 = phi <2 x float> [ undef, %77 ], [ %107, %112 ]
%116 = phi float [ undef, %77 ], [ %113, %112 ]
%117 = phi i64 [ 0, %77 ], [ %109, %112 ]
%118 = phi <2 x float> [ zeroinitializer, %77 ], [ %107, %112 ]
%119 = icmp eq i64 %78, 0
br i1 %119, label %132, label %120
120: ; preds = %114
%121 = getelementptr inbounds float, float* %0, i64 %117
%122 = load float, float* %121
%123 = fsub float %122, %76
%124 = getelementptr inbounds float, float* %1, i64 %117
%125 = load float, float* %124
%126 = insertelement <2 x float> poison, float %123, i64 0
%127 = shufflevector <2 x float> %126, <2 x float> poison, <2 x i32> zeroinitializer
%128 = insertelement <2 x float> poison, float %125, i64 0
%129 = insertelement <2 x float> %128, float %123, i64 1
%130 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %127, <2 x float> %129, <2 x float> %118)
%131 = extractelement <2 x float> %130, i64 0
store float %131, float* %4
br label %132
132: ; preds = %114, %120
%133 = phi <2 x float> [ %115, %114 ], [ %130, %120 ]
%134 = phi float [ %116, %114 ], [ %131, %120 ]
%135 = extractelement <2 x float> %133, i64 1
%136 = fdiv float %134, %135
br label %137
137: ; preds = %7, %132, %72
%138 = phi float [ %75, %132 ], [ %75, %72 ], [ %8, %7 ]
%139 = phi float [ %74, %132 ], [ %74, %72 ], [ 0.000000e+00, %7 ]
%140 = phi float [ %73, %132 ], [ %73, %72 ], [ 0.000000e+00, %7 ]
%141 = phi float [ %136, %132 ], [ 0x7FF8000000000000, %72 ], [ 0x7FF8000000000000, %7 ]
store float %141, float* %4
%142 = fneg float %140
%143 = tail call float @llvm.fmuladd.f32(float %142, float %141, float %139)
%144 = fdiv float %143, %138
store float %144, float* %3
ret void
}