void movavg(double *t_sim, double *t_obs, int length) {
  int t;
  t_sim[0] = 0.5 * (t_obs[0] + t_obs[1]);
  t_sim[length - 1] = 0.5 * (t_obs[length - 2] + t_obs[length - 3]);
  for (t = 1; t < length - 1; t++) {
    t_sim[t] = (t_obs[t - 1] + 0.5 * t_obs[t] + t_obs[t + 1]) / 2.5;
  }
}


x86 assembly (clang, -O0):
<movavg>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x8(%rax),%xmm1
movsd  0xed8(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xea0(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11f6 <movavg+0xf6>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xe4b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xe31(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    117d <movavg+0x7d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<movavg>:
movsd  (%rsi),%xmm1
addsd  0x8(%rsi),%xmm1
movsd  0xeef(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi)
movslq %edx,%rax
movsd  -0x10(%rsi,%rax,8),%xmm1
addsd  -0x18(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rdi,%rax,8)
cmp    $0x3,%edx
jl     11fa <movavg+0xfa>
add    $0xffffffff,%edx
mov    %edx,%eax
lea    -0x1(%rax),%r8
mov    $0x1,%ecx
cmp    $0x2,%r8
jb     11c5 <movavg+0xc5>
lea    0x8(%rdi),%r9
lea    (%rsi,%rax,8),%rdx
add    $0x8,%rdx
cmp    %rdx,%r9
jae    1169 <movavg+0x69>
lea    (%rdi,%rax,8),%rdx
cmp    %rsi,%rdx
ja     11c5 <movavg+0xc5>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
mov    %r8,%rcx
or     $0x1,%rcx
xor    %edx,%edx
movapd 0xe8f(%rip),%xmm1
movapd 0xe97(%rip),%xmm2
nopl   0x0(%rax)
movupd (%rsi,%rdx,8),%xmm3
movupd 0x8(%rsi,%rdx,8),%xmm4
movupd 0x10(%rsi,%rdx,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
divpd  %xmm2,%xmm4
movupd %xmm4,0x8(%rdi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r9
jne    1190 <movavg+0x90>
cmp    %r9,%r8
je     11fa <movavg+0xfa>
movsd  0xe3b(%rip),%xmm1
nopl   (%rax)
movsd  (%rsi,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  -0x8(%rsi,%rcx,8),%xmm2
addsd  0x8(%rsi,%rcx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rcx,8)
lea    0x1(%rcx),%rdx
mov    %rdx,%rcx
cmp    %rdx,%rax
jne    11d0 <movavg+0xd0>
ret

LLVM IR (-O0):
define void @movavg(double* %0, double* %1, i32 %2) {
%4 = alloca double*
%5 = alloca double*
%6 = alloca i32
%7 = alloca i32
store double* %0, double** %4
store double* %1, double** %5
store i32 %2, i32* %6
%8 = load double*, double** %5
%9 = getelementptr inbounds double, double* %8, i64 0
%10 = load double, double* %9
%11 = load double*, double** %5
%12 = getelementptr inbounds double, double* %11, i64 1
%13 = load double, double* %12
%14 = fadd double %10, %13
%15 = fmul double 5.000000e-01, %14
%16 = load double*, double** %4
%17 = getelementptr inbounds double, double* %16, i64 0
store double %15, double* %17
%18 = load double*, double** %5
%19 = load i32, i32* %6
%20 = sub nsw i32 %19, 2
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds double, double* %18, i64 %21
%23 = load double, double* %22
%24 = load double*, double** %5
%25 = load i32, i32* %6
%26 = sub nsw i32 %25, 3
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds double, double* %24, i64 %27
%29 = load double, double* %28
%30 = fadd double %23, %29
%31 = fmul double 5.000000e-01, %30
%32 = load double*, double** %4
%33 = load i32, i32* %6
%34 = sub nsw i32 %33, 1
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds double, double* %32, i64 %35
store double %31, double* %36
store i32 1, i32* %7
br label %37
37: ; preds = %67, %3
%38 = load i32, i32* %7
%39 = load i32, i32* %6
%40 = sub nsw i32 %39, 1
%41 = icmp slt i32 %38, %40
br i1 %41, label %42, label %70
42: ; preds = %37
%43 = load double*, double** %5
%44 = load i32, i32* %7
%45 = sub nsw i32 %44, 1
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds double, double* %43, i64 %46
%48 = load double, double* %47
%49 = load double*, double** %5
%50 = load i32, i32* %7
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
%53 = load double, double* %52
%54 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %53, double %48)
%55 = load double*, double** %5
%56 = load i32, i32* %7
%57 = add nsw i32 %56, 1
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %55, i64 %58
%60 = load double, double* %59
%61 = fadd double %54, %60
%62 = fdiv double %61, 2.500000e+00
%63 = load double*, double** %4
%64 = load i32, i32* %7
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds double, double* %63, i64 %65
store double %62, double* %66
br label %67
67: ; preds = %42
%68 = load i32, i32* %7
%69 = add nsw i32 %68, 1
store i32 %69, i32* %7
br label %37
70: ; preds = %37
ret void
}

LLVM IR (-O2):
define void @movavg(double* nocapture writeonly %0, double* nocapture %1, i32 %2) {
%4 = load double, double* %1
%5 = getelementptr inbounds double, double* %1, i64 1
%6 = load double, double* %5
%7 = fadd double %4, %6
%8 = fmul double %7, 5.000000e-01
store double %8, double* %0
%9 = add nsw i32 %2, -2
%10 = sext i32 %9 to i64
%11 = getelementptr inbounds double, double* %1, i64 %10
%12 = load double, double* %11
%13 = add nsw i32 %2, -3
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds double, double* %1, i64 %14
%16 = load double, double* %15
%17 = fadd double %12, %16
%18 = fmul double %17, 5.000000e-01
%19 = add nsw i32 %2, -1
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds double, double* %0, i64 %20
store double %18, double* %21
%22 = icmp sgt i32 %2, 2
br i1 %22, label %23, label %77
23: ; preds = %3
%24 = zext i32 %19 to i64
%25 = add nsw i64 %24, -1
%26 = icmp ult i64 %25, 2
br i1 %26, label %60, label %27
27: ; preds = %23
%28 = getelementptr double, double* %0, i64 1
%29 = getelementptr double, double* %0, i64 %24
%30 = add nuw nsw i64 %24, 1
%31 = getelementptr double, double* %1, i64 %30
%32 = icmp ult double* %28, %31
%33 = icmp ugt double* %29, %1
%34 = and i1 %32, %33
br i1 %34, label %60, label %35
35: ; preds = %27
%36 = and i64 %25, -2
%37 = or i64 %25, 1
br label %38
38: ; preds = %38, %35
%39 = phi i64 [ 0, %35 ], [ %56, %38 ]
%40 = or i64 %39, 1
%41 = getelementptr inbounds double, double* %1, i64 %39
%42 = bitcast double* %41 to <2 x double>*
%43 = load <2 x double>, <2 x double>* %42
%44 = getelementptr inbounds double, double* %1, i64 %40
%45 = bitcast double* %44 to <2 x double>*
%46 = load <2 x double>, <2 x double>* %45
%47 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %46, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %43)
%48 = add i64 %39, 2
%49 = getelementptr inbounds double, double* %1, i64 %48
%50 = bitcast double* %49 to <2 x double>*
%51 = load <2 x double>, <2 x double>* %50
%52 = fadd <2 x double> %47, %51
%53 = fdiv <2 x double> %52, <double 2.500000e+00, double 2.500000e+00>
%54 = getelementptr inbounds double, double* %0, i64 %40
%55 = bitcast double* %54 to <2 x double>*
store <2 x double> %53, <2 x double>* %55
%56 = add nuw i64 %39, 2
%57 = icmp eq i64 %56, %36
br i1 %57, label %58, label %38
58: ; preds = %38
%59 = icmp eq i64 %25, %36
br i1 %59, label %77, label %60
60: ; preds = %27, %23, %58
%61 = phi i64 [ 1, %27 ], [ 1, %23 ], [ %37, %58 ]
br label %62
62: ; preds = %60, %62
%63 = phi i64 [ %70, %62 ], [ %61, %60 ]
%64 = add nsw i64 %63, -1
%65 = getelementptr inbounds double, double* %1, i64 %64
%66 = load double, double* %65
%67 = getelementptr inbounds double, double* %1, i64 %63
%68 = load double, double* %67
%69 = tail call double @llvm.fmuladd.f64(double %68, double 5.000000e-01, double %66)
%70 = add nuw nsw i64 %63, 1
%71 = getelementptr inbounds double, double* %1, i64 %70
%72 = load double, double* %71
%73 = fadd double %69, %72
%74 = fdiv double %73, 2.500000e+00
%75 = getelementptr inbounds double, double* %0, i64 %63
store double %74, double* %75
%76 = icmp eq i64 %70, %24
br i1 %76, label %77, label %62
77: ; preds = %62, %58, %3
ret void
}