void advanced_smooth_gaps(float *prof, int len, int window, float strength) {
  float tmp_gpo;
  float tmp_gpe;
  float tmp_tgpe;
  int i, j;
  if (!(window & 1)) {
    window--;
  }
  for (i = (window / 2); i < len - (window / 2); i++) {
    tmp_gpo = 0.0;
    tmp_gpe = 0.0;
    tmp_tgpe = 0.0;
    for (j = -(window / 2); j < (window / 2); j++) {
      tmp_gpo += (float)prof[55 + ((i + j) * 64)] * strength;
      tmp_gpe += (float)prof[56 + ((i + j) * 64)] * strength;
      tmp_tgpe += (float)prof[57 + ((i + j) * 64)] * strength;
    }
    tmp_gpo /= window;
    tmp_gpe /= window;
    tmp_tgpe /= window;
    prof[27 + (i * 64)] = prof[55 + (i * 64)] * (1.0 - strength) + tmp_gpo;
    prof[28 + (i * 64)] = prof[56 + (i * 64)] * (1.0 - strength) + tmp_gpe;
    prof[29 + (i * 64)] = prof[57 + (i * 64)] * (1.0 - strength) + tmp_tgpe;
  }
}


x86 assembly (clang, -O0):
<advanced_smooth_gaps>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    -0x10(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    112b <advanced_smooth_gaps+0x2b>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x10(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x2c(%rbp),%eax
sub    %edx,%ecx
cmp    %ecx,%eax
jge    1390 <advanced_smooth_gaps+0x290>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
cmp    %ecx,%eax
jge    1241 <advanced_smooth_gaps+0x141>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
shl    $0x6,%ecx
add    $0x37,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
shl    $0x6,%ecx
add    $0x38,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
shl    $0x6,%ecx
add    $0x39,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1188 <advanced_smooth_gaps+0x88>
cvtsi2ssl -0x10(%rbp),%xmm1
movss  -0x18(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
cvtsi2ssl -0x10(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
cvtsi2ssl -0x10(%rbp),%xmm1
movss  -0x20(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x6,%ecx
add    $0x37,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x14(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xd5c(%rip),%xmm2
subsd  %xmm1,%xmm2
movss  -0x18(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1b,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x6,%ecx
add    $0x38,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x14(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xd04(%rip),%xmm2
subsd  %xmm1,%xmm2
movss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1c,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x6,%ecx
add    $0x39,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x14(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xcac(%rip),%xmm2
subsd  %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1d,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1139 <advanced_smooth_gaps+0x39>
pop    %rbp
ret

x86 assembly (clang, -O2):
<advanced_smooth_gaps>:
push   %rbx
mov    %edx,%eax
and    $0x1,%eax
lea    (%rdx,%rax,1),%r9d
add    $0xffffffff,%r9d
add    %eax,%edx
mov    %r9d,%eax
shr    $0x1f,%eax
add    %edx,%eax
add    $0xffffffff,%eax
sar    %eax
sub    %eax,%esi
cmp    %esi,%eax
jge    1278 <advanced_smooth_gaps+0x178>
movslq %eax,%rcx
cvtsi2ss %r9d,%xmm1
neg    %eax
cvtss2sd %xmm0,%xmm3
movsd  0xec3(%rip),%xmm2
subsd  %xmm3,%xmm2
movslq %eax,%r8
movslq %esi,%r10
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
mov    $0x39,%r11d
mov    %rcx,%rsi
jmp    120e <advanced_smooth_gaps+0x10e>
nopl   0x0(%rax)
xorps  %xmm4,%xmm4
xorps  %xmm5,%xmm5
mov    %esi,%eax
divss  %xmm1,%xmm5
movaps %xmm4,%xmm6
divss  %xmm1,%xmm6
shufps $0x55,%xmm4,%xmm4
divss  %xmm1,%xmm4
shl    $0x6,%eax
lea    0x37(%rax),%edx
movslq %edx,%rdx
movss  (%rdi,%rdx,4),%xmm7
cvtss2sd %xmm7,%xmm7
cvtss2sd %xmm5,%xmm5
mulsd  %xmm2,%xmm7
addsd  %xmm5,%xmm7
xorps  %xmm5,%xmm5
cvtsd2ss %xmm7,%xmm5
lea    0x1b(%rax),%edx
movslq %edx,%rdx
movss  %xmm5,(%rdi,%rdx,4)
lea    0x38(%rax),%edx
movslq %edx,%rdx
movss  (%rdi,%rdx,4),%xmm5
cvtss2sd %xmm5,%xmm5
cvtss2sd %xmm6,%xmm6
mulsd  %xmm2,%xmm5
addsd  %xmm6,%xmm5
cvtsd2ss %xmm5,%xmm5
lea    0x1c(%rax),%edx
movslq %edx,%rdx
movss  %xmm5,(%rdi,%rdx,4)
lea    0x39(%rax),%edx
movslq %edx,%rdx
movss  (%rdi,%rdx,4),%xmm5
cvtss2sd %xmm5,%xmm5
cvtss2sd %xmm4,%xmm4
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
xorps  %xmm4,%xmm4
cvtsd2ss %xmm5,%xmm4
or     $0x1d,%eax
cltq
movss  %xmm4,(%rdi,%rax,4)
add    $0x1,%rsi
add    $0x40,%r11d
cmp    %r10,%rsi
je     1278 <advanced_smooth_gaps+0x178>
cmp    $0x2,%r9d
jl     1160 <advanced_smooth_gaps+0x60>
xorps  %xmm7,%xmm7
xorps  %xmm5,%xmm5
mov    %r11d,%eax
mov    %r8,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm7,%xmm6
lea    -0x2(%rax),%ebx
movslq %ebx,%rbx
movss  (%rdi,%rbx,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm4,%xmm5
lea    -0x1(%rax),%ebx
movslq %ebx,%rbx
cltq
movss  (%rdi,%rax,4),%xmm7
movss  (%rdi,%rbx,4),%xmm4
unpcklps %xmm7,%xmm4
mulps  %xmm3,%xmm4
movaps %xmm4,%xmm7
addps  %xmm6,%xmm7
add    $0x1,%rdx
add    $0x40,%eax
cmp    %rcx,%rdx
jl     1230 <advanced_smooth_gaps+0x130>
addps  %xmm6,%xmm4
jmp    1166 <advanced_smooth_gaps+0x66>
pop    %rbx
ret

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

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