void af_filter_bilinear(float *a, float *b, float *k, float fs, float *coef) {
  float ad, bd;
  ad = 4. * a[2] * fs * fs + 2. * a[1] * fs + a[0];
  bd = 4. * b[2] * fs * fs + 2. * b[1] * fs + b[0];
  *k *= ad / bd;
  *coef++ = (2. * b[0] - 8. * b[2] * fs * fs) / bd;
  *coef++ = (4. * b[2] * fs * fs - 2. * b[1] * fs + b[0]) / bd;
  *coef++ = (2. * a[0] - 8. * a[2] * fs * fs) / ad;
  *coef = (4. * a[2] * fs * fs - 2. * a[1] * fs + a[0]) / ad;
}


x86 assembly (clang, -O0):
<af_filter_bilinear>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xeda(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm3
movsd  0xea3(%rip),%xmm1
mulsd  %xmm3,%xmm1
movss  -0x1c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe64(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm3
movsd  0xe2d(%rip),%xmm1
mulsd  %xmm3,%xmm1
movss  -0x1c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
divss  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xdd4(%rip),%xmm1
mulsd  %xmm2,%xmm1
movss  -0x1c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
movss  -0x1c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd56(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm3
movsd  0xd1f(%rip),%xmm1
mulsd  %xmm3,%xmm1
movss  -0x1c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xcaa(%rip),%xmm1
mulsd  %xmm2,%xmm1
movss  -0x1c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
movss  -0x1c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc2c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm3
movsd  0xbf5(%rip),%xmm1
mulsd  %xmm3,%xmm1
movss  -0x1c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<af_filter_bilinear>:
movss  0x8(%rdi),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xeee(%rip),%xmm8
mulsd  %xmm8,%xmm2
cvtss2sd %xmm0,%xmm0
mulsd  %xmm0,%xmm2
movss  (%rdi),%xmm3
movss  0x4(%rdi),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm4,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm2
addsd  %xmm4,%xmm2
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movss  0x8(%rsi),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm8,%xmm3
mulsd  %xmm0,%xmm3
movss  (%rsi),%xmm4
movss  0x4(%rsi),%xmm5
cvtss2sd %xmm5,%xmm5
addsd  %xmm5,%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm3
addsd  %xmm5,%xmm3
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
cvtsd2ss %xmm4,%xmm4
movaps %xmm2,%xmm3
divss  %xmm4,%xmm3
mulss  (%rdx),%xmm3
movss  %xmm3,(%rdx)
movss  (%rsi),%xmm3
movss  0x8(%rsi),%xmm5
cvtss2sd %xmm3,%xmm6
cvtss2sd %xmm5,%xmm5
movsd  0xe5a(%rip),%xmm3
mulsd  %xmm3,%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm6,%xmm6
addsd  %xmm5,%xmm6
xorps  %xmm5,%xmm5
cvtss2sd %xmm4,%xmm5
divsd  %xmm5,%xmm6
xorps  %xmm4,%xmm4
cvtsd2ss %xmm6,%xmm4
movss  %xmm4,(%rcx)
movss  0x8(%rsi),%xmm4
xorps  %xmm6,%xmm6
cvtss2sd %xmm4,%xmm6
mulsd  %xmm8,%xmm6
mulsd  %xmm0,%xmm6
movss  (%rsi),%xmm7
movss  0x4(%rsi),%xmm4
xorps  %xmm1,%xmm1
cvtss2sd %xmm4,%xmm1
movsd  0xe0b(%rip),%xmm4
mulsd  %xmm4,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm6
addsd  %xmm1,%xmm6
xorps  %xmm1,%xmm1
cvtss2sd %xmm7,%xmm1
addsd  %xmm6,%xmm1
divsd  %xmm5,%xmm1
cvtsd2ss %xmm1,%xmm1
cvtss2sd %xmm2,%xmm2
movss  %xmm1,0x4(%rcx)
movss  (%rdi),%xmm1
movss  0x8(%rdi),%xmm5
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm5,%xmm5
mulsd  %xmm3,%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm1,%xmm1
addsd  %xmm5,%xmm1
divsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x8(%rcx)
movss  0x8(%rdi),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm8,%xmm1
mulsd  %xmm0,%xmm1
movss  (%rdi),%xmm3
movss  0x4(%rdi),%xmm5
cvtss2sd %xmm5,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm1
addsd  %xmm5,%xmm1
cvtss2sd %xmm3,%xmm0
addsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc(%rcx)
ret

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

LLVM IR (-O2):
define void @af_filter_bilinear(float* nocapture %0, float* nocapture %1, float* nocapture %2, float %3, float* nocapture writeonly %4) {
%6 = getelementptr inbounds float, float* %0, i64 2
%7 = load float, float* %6
%8 = fpext float %7 to double
%9 = fmul double %8, 4.000000e+00
%10 = fpext float %3 to double
%11 = fmul double %9, %10
%12 = getelementptr inbounds float, float* %0, i64 1
%13 = load float, float* %12
%14 = fpext float %13 to double
%15 = fmul double %14, 2.000000e+00
%16 = fmul double %15, %10
%17 = tail call double @llvm.fmuladd.f64(double %11, double %10, double %16)
%18 = load float, float* %0
%19 = fpext float %18 to double
%20 = fadd double %17, %19
%21 = fptrunc double %20 to float
%22 = getelementptr inbounds float, float* %1, i64 2
%23 = load float, float* %22
%24 = fpext float %23 to double
%25 = fmul double %24, 4.000000e+00
%26 = fmul double %25, %10
%27 = getelementptr inbounds float, float* %1, i64 1
%28 = load float, float* %27
%29 = fpext float %28 to double
%30 = fmul double %29, 2.000000e+00
%31 = fmul double %30, %10
%32 = tail call double @llvm.fmuladd.f64(double %26, double %10, double %31)
%33 = load float, float* %1
%34 = fpext float %33 to double
%35 = fadd double %32, %34
%36 = fptrunc double %35 to float
%37 = fdiv float %21, %36
%38 = load float, float* %2
%39 = fmul float %38, %37
store float %39, float* %2
%40 = load float, float* %1
%41 = fpext float %40 to double
%42 = load float, float* %22
%43 = fpext float %42 to double
%44 = fmul double %43, -8.000000e+00
%45 = fmul double %44, %10
%46 = fmul double %45, %10
%47 = tail call double @llvm.fmuladd.f64(double %41, double 2.000000e+00, double %46)
%48 = fpext float %36 to double
%49 = fdiv double %47, %48
%50 = fptrunc double %49 to float
%51 = getelementptr inbounds float, float* %4, i64 1
store float %50, float* %4
%52 = load float, float* %22
%53 = fpext float %52 to double
%54 = fmul double %53, 4.000000e+00
%55 = fmul double %54, %10
%56 = load float, float* %27
%57 = fpext float %56 to double
%58 = fmul double %57, -2.000000e+00
%59 = fmul double %58, %10
%60 = tail call double @llvm.fmuladd.f64(double %55, double %10, double %59)
%61 = load float, float* %1
%62 = fpext float %61 to double
%63 = fadd double %60, %62
%64 = fdiv double %63, %48
%65 = fptrunc double %64 to float
%66 = getelementptr inbounds float, float* %4, i64 2
store float %65, float* %51
%67 = load float, float* %0
%68 = fpext float %67 to double
%69 = load float, float* %6
%70 = fpext float %69 to double
%71 = fmul double %70, -8.000000e+00
%72 = fmul double %71, %10
%73 = fmul double %72, %10
%74 = tail call double @llvm.fmuladd.f64(double %68, double 2.000000e+00, double %73)
%75 = fpext float %21 to double
%76 = fdiv double %74, %75
%77 = fptrunc double %76 to float
%78 = getelementptr inbounds float, float* %4, i64 3
store float %77, float* %66
%79 = load float, float* %6
%80 = fpext float %79 to double
%81 = fmul double %80, 4.000000e+00
%82 = fmul double %81, %10
%83 = load float, float* %12
%84 = fpext float %83 to double
%85 = fmul double %84, -2.000000e+00
%86 = fmul double %85, %10
%87 = tail call double @llvm.fmuladd.f64(double %82, double %10, double %86)
%88 = load float, float* %0
%89 = fpext float %88 to double
%90 = fadd double %87, %89
%91 = fdiv double %90, %75
%92 = fptrunc double %91 to float
store float %92, float* %78
ret void
}