float aster(float red, float green, float blue) {
  float bright = 0.3 * red + 0.5 * green + 0.2 * blue;
  red = red / bright;
  green = green / (bright * bright);
  blue = (1 - blue) / bright;
  return red + green + blue;
}


x86 assembly (clang, -O0):
<aster>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xeeb(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0xed7(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xeb6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp)
movss  -0x4(%rbp),%xmm0
divss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x8(%rbp),%xmm0
movss  -0x10(%rbp),%xmm1
mulss  -0x10(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x8(%rbp)
movss  0xe6e(%rip),%xmm0
subss  -0xc(%rbp),%xmm0
divss  -0x10(%rbp),%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0x4(%rbp),%xmm0
addss  -0x8(%rbp),%xmm0
addss  -0xc(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<aster>:
cvtss2sd %xmm1,%xmm3
mulsd  0xef4(%rip),%xmm3
cvtss2sd %xmm0,%xmm4
mulsd  0xef0(%rip),%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
mulsd  0xee5(%rip),%xmm3
addsd  %xmm4,%xmm3
cvtsd2ss %xmm3,%xmm3
movaps %xmm3,%xmm4
mulss  %xmm3,%xmm4
divss  %xmm4,%xmm1
movss  0xed2(%rip),%xmm4
subss  %xmm2,%xmm4
unpcklps %xmm0,%xmm4
shufps $0x0,%xmm3,%xmm3
divps  %xmm3,%xmm4
movaps %xmm4,%xmm0
shufps $0x55,%xmm4,%xmm0
addss  %xmm1,%xmm0
addss  %xmm4,%xmm0
ret

LLVM IR (-O0):
define float @aster(float %0, float %1, float %2) {
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
store float %0, float* %4
store float %1, float* %5
store float %2, float* %6
%8 = load float, float* %4
%9 = fpext float %8 to double
%10 = load float, float* %5
%11 = fpext float %10 to double
%12 = fmul double 5.000000e-01, %11
%13 = call double @llvm.fmuladd.f64(double 3.000000e-01, double %9, double %12)
%14 = load float, float* %6
%15 = fpext float %14 to double
%16 = call double @llvm.fmuladd.f64(double 2.000000e-01, double %15, double %13)
%17 = fptrunc double %16 to float
store float %17, float* %7
%18 = load float, float* %4
%19 = load float, float* %7
%20 = fdiv float %18, %19
store float %20, float* %4
%21 = load float, float* %5
%22 = load float, float* %7
%23 = load float, float* %7
%24 = fmul float %22, %23
%25 = fdiv float %21, %24
store float %25, float* %5
%26 = load float, float* %6
%27 = fsub float 1.000000e+00, %26
%28 = load float, float* %7
%29 = fdiv float %27, %28
store float %29, float* %6
%30 = load float, float* %4
%31 = load float, float* %5
%32 = fadd float %30, %31
%33 = load float, float* %6
%34 = fadd float %32, %33
ret float %34
}

LLVM IR (-O2):
define float @aster(float %0, float %1, float %2) {
%4 = fpext float %0 to double
%5 = fpext float %1 to double
%6 = fmul double %5, 5.000000e-01
%7 = tail call double @llvm.fmuladd.f64(double %4, double 3.000000e-01, double %6)
%8 = fpext float %2 to double
%9 = tail call double @llvm.fmuladd.f64(double %8, double 2.000000e-01, double %7)
%10 = fptrunc double %9 to float
%11 = fmul float %10, %10
%12 = fdiv float %1, %11
%13 = fsub float 1.000000e+00, %2
%14 = insertelement <2 x float> poison, float %0, i64 1
%15 = insertelement <2 x float> %14, float %13, i64 0
%16 = insertelement <2 x float> poison, float %10, i64 0
%17 = shufflevector <2 x float> %16, <2 x float> poison, <2 x i32> zeroinitializer
%18 = fdiv <2 x float> %15, %17
%19 = extractelement <2 x float> %18, i64 1
%20 = fadd float %19, %12
%21 = extractelement <2 x float> %18, i64 0
%22 = fadd float %21, %20
ret float %22
}