double quotient_sin_func(x, y)
double x, y;
{
  return (-(x * x * x - x) +
          (x * x * x * x * x / 20.0 - x * x * x / 6.0 + 7.0 * x / 60.0) *
              (y * y) -
          (x * x * x * x * x * x * x / 840.0 - x * x * x * x * x / 120.0 +
           7.0 * x * x * x / 360.0 - 31.0 * x / 2520.0) *
              (y * y * y * y));
}


x86 assembly (clang, -O0):
<quotient_sin_func>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm2
movsd  -0x8(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x8(%rbp),%xmm1
mulsd  -0x8(%rbp),%xmm1
mulsd  -0x8(%rbp),%xmm1
mulsd  -0x8(%rbp),%xmm1
mulsd  -0x8(%rbp),%xmm1
movsd  0xec7(%rip),%xmm2
divsd  %xmm2,%xmm1
movsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
movsd  0xea4(%rip),%xmm3
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
movsd  0xe74(%rip),%xmm2
mulsd  -0x8(%rbp),%xmm2
movsd  0xe7f(%rip),%xmm3
divsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0x10(%rbp),%xmm2
mulsd  -0x10(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
movsd  0xe32(%rip),%xmm2
divsd  %xmm2,%xmm0
movsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
movsd  0xe05(%rip),%xmm3
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm0
movsd  0xded(%rip),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
mulsd  -0x8(%rbp),%xmm2
movsd  0xdce(%rip),%xmm3
divsd  %xmm3,%xmm2
addsd  %xmm2,%xmm0
movsd  0xdb6(%rip),%xmm2
mulsd  -0x8(%rbp),%xmm2
movsd  0xda1(%rip),%xmm3
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm0
movsd  -0x10(%rbp),%xmm2
mulsd  -0x10(%rbp),%xmm2
mulsd  -0x10(%rbp),%xmm2
mulsd  -0x10(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<quotient_sin_func>:
movapd %xmm0,%xmm2
movapd %xmm0,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm4
movapd %xmm4,%xmm5
movapd %xmm4,%xmm0
mulsd  %xmm2,%xmm0
divsd  0xedc(%rip),%xmm4
movapd %xmm2,%xmm6
unpcklpd %xmm2,%xmm6
movapd 0xedc(%rip),%xmm3
unpcklpd %xmm0,%xmm3
mulpd  %xmm6,%xmm3
movapd %xmm3,%xmm7
divpd  0xed8(%rip),%xmm7
subsd  %xmm2,%xmm5
movapd %xmm7,%xmm0
unpckhpd %xmm7,%xmm0
addsd  %xmm4,%xmm0
addsd  %xmm7,%xmm0
movapd %xmm1,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm4,%xmm0
movapd %xmm3,%xmm7
unpckhpd %xmm3,%xmm7
mulsd  %xmm2,%xmm7
mulsd  %xmm2,%xmm7
shufpd $0x2,%xmm3,%xmm7
divpd  0xeab(%rip),%xmm7
subsd  %xmm5,%xmm0
mulsd  %xmm2,%xmm3
shufpd $0x2,0xeaa(%rip),%xmm3
mulpd  %xmm6,%xmm3
divpd  0xeae(%rip),%xmm3
movapd %xmm7,%xmm2
unpckhpd %xmm7,%xmm2
subsd  %xmm2,%xmm7
addsd  %xmm3,%xmm7
unpckhpd %xmm3,%xmm3
subsd  %xmm3,%xmm7
mulsd  %xmm1,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm7,%xmm4
subsd  %xmm4,%xmm0
ret

LLVM IR (-O0):
define double @quotient_sin_func(double %0, double %1) {
%3 = alloca double
%4 = alloca double
store double %0, double* %3
store double %1, double* %4
%5 = load double, double* %3
%6 = load double, double* %3
%7 = fmul double %5, %6
%8 = load double, double* %3
%9 = load double, double* %3
%10 = fneg double %9
%11 = call double @llvm.fmuladd.f64(double %7, double %8, double %10)
%12 = fneg double %11
%13 = load double, double* %3
%14 = load double, double* %3
%15 = fmul double %13, %14
%16 = load double, double* %3
%17 = fmul double %15, %16
%18 = load double, double* %3
%19 = fmul double %17, %18
%20 = load double, double* %3
%21 = fmul double %19, %20
%22 = fdiv double %21, 2.000000e+01
%23 = load double, double* %3
%24 = load double, double* %3
%25 = fmul double %23, %24
%26 = load double, double* %3
%27 = fmul double %25, %26
%28 = fdiv double %27, 6.000000e+00
%29 = fsub double %22, %28
%30 = load double, double* %3
%31 = fmul double 7.000000e+00, %30
%32 = fdiv double %31, 6.000000e+01
%33 = fadd double %29, %32
%34 = load double, double* %4
%35 = load double, double* %4
%36 = fmul double %34, %35
%37 = call double @llvm.fmuladd.f64(double %33, double %36, double %12)
%38 = load double, double* %3
%39 = load double, double* %3
%40 = fmul double %38, %39
%41 = load double, double* %3
%42 = fmul double %40, %41
%43 = load double, double* %3
%44 = fmul double %42, %43
%45 = load double, double* %3
%46 = fmul double %44, %45
%47 = load double, double* %3
%48 = fmul double %46, %47
%49 = load double, double* %3
%50 = fmul double %48, %49
%51 = fdiv double %50, 8.400000e+02
%52 = load double, double* %3
%53 = load double, double* %3
%54 = fmul double %52, %53
%55 = load double, double* %3
%56 = fmul double %54, %55
%57 = load double, double* %3
%58 = fmul double %56, %57
%59 = load double, double* %3
%60 = fmul double %58, %59
%61 = fdiv double %60, 1.200000e+02
%62 = fsub double %51, %61
%63 = load double, double* %3
%64 = fmul double 7.000000e+00, %63
%65 = load double, double* %3
%66 = fmul double %64, %65
%67 = load double, double* %3
%68 = fmul double %66, %67
%69 = fdiv double %68, 3.600000e+02
%70 = fadd double %62, %69
%71 = load double, double* %3
%72 = fmul double 3.100000e+01, %71
%73 = fdiv double %72, 2.520000e+03
%74 = fsub double %70, %73
%75 = load double, double* %4
%76 = load double, double* %4
%77 = fmul double %75, %76
%78 = load double, double* %4
%79 = fmul double %77, %78
%80 = load double, double* %4
%81 = fmul double %79, %80
%82 = fneg double %74
%83 = call double @llvm.fmuladd.f64(double %82, double %81, double %37)
ret double %83
}

LLVM IR (-O2):
define double @quotient_sin_func(double %0, double %1) {
%3 = fmul double %0, %0
%4 = fneg double %0
%5 = tail call double @llvm.fmuladd.f64(double %3, double %0, double %4)
%6 = fneg double %5
%7 = fmul double %3, %0
%8 = fmul double %7, %0
%9 = fdiv double %7, 6.000000e+00
%10 = insertelement <2 x double> poison, double %0, i64 0
%11 = shufflevector <2 x double> %10, <2 x double> poison, <2 x i32> zeroinitializer
%12 = insertelement <2 x double> <double 7.000000e+00, double poison>, double %8, i64 1
%13 = fmul <2 x double> %11, %12
%14 = fdiv <2 x double> %13, <double 6.000000e+01, double 2.000000e+01>
%15 = extractelement <2 x double> %14, i64 1
%16 = fsub double %15, %9
%17 = extractelement <2 x double> %14, i64 0
%18 = fadd double %17, %16
%19 = fmul double %1, %1
%20 = tail call double @llvm.fmuladd.f64(double %18, double %19, double %6)
%21 = extractelement <2 x double> %13, i64 1
%22 = fmul double %21, %0
%23 = fmul double %22, %0
%24 = insertelement <2 x double> %13, double %23, i64 0
%25 = fdiv <2 x double> %24, <double 8.400000e+02, double 1.200000e+02>
%26 = shufflevector <2 x double> %25, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%27 = fsub <2 x double> %25, %26
%28 = extractelement <2 x double> %13, i64 0
%29 = fmul double %28, %0
%30 = insertelement <2 x double> <double poison, double 3.100000e+01>, double %29, i64 0
%31 = fmul <2 x double> %11, %30
%32 = fdiv <2 x double> %31, <double 3.600000e+02, double 2.520000e+03>
%33 = fadd <2 x double> %32, %27
%34 = shufflevector <2 x double> %32, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%35 = fsub <2 x double> %33, %34
%36 = extractelement <2 x double> %35, i64 0
%37 = fmul double %19, %1
%38 = fmul double %37, %1
%39 = fneg double %36
%40 = tail call double @llvm.fmuladd.f64(double %39, double %38, double %20)
ret double %40
}