#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
long double powl(long double, int);
long double sqrtl(int);
long double _den(long double a, long double b, long double c, long double d,
                 long double e, long double f) {
  return sqrtl(1. + (c * c * d * d + c * c * e * e - 2 * a * c * d * f -
                     2 * b * c * e * f + a * a * f * f + b * b * f * f) /
                        powl(b * d - a * e, 2));
}


x86 assembly (clang, -O0):
<_den>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
fldt   0x60(%rbp)
fldt   0x50(%rbp)
fldt   0x40(%rbp)
fldt   0x30(%rbp)
fldt   0x20(%rbp)
fldt   0x10(%rbp)
fstpt  -0x10(%rbp)
fstpt  -0x20(%rbp)
fstpt  -0x30(%rbp)
fstpt  -0x40(%rbp)
fstpt  -0x50(%rbp)
fstpt  -0x60(%rbp)
fldt   -0x30(%rbp)
fld    %st(0)
fmul   %st(1),%st
fldt   -0x40(%rbp)
fld    %st(1)
fmul   %st(1),%st
fldt   -0x50(%rbp)
fmul   %st,%st(3)
fmul   %st,%st(3)
fxch   %st(1)
fmul   %st(2),%st
faddp  %st,%st(3)
fldt   -0x10(%rbp)
fld    %st(0)
fadd   %st(1),%st
fmul   %st(5),%st
fmul   %st(3),%st
fldt   -0x60(%rbp)
fmul   %st,%st(1)
fxch   %st(5)
fsubp  %st,%st(1)
fldt   -0x20(%rbp)
fld    %st(0)
fstpt  -0x80(%rbp)
fadd   %st,%st(0)
fmulp  %st,%st(6)
fldt   -0x80(%rbp)
fxch   %st(6)
fmul   %st(3),%st
fmul   %st(5),%st
fsubrp %st,%st(1)
fld    %st(1)
fmul   %st(2),%st
fmul   %st(5),%st
fmul   %st(5),%st
faddp  %st,%st(1)
fld    %st(5)
fmul   %st(6),%st
fmul   %st(5),%st
fmulp  %st,%st(5)
faddp  %st,%st(4)
fxch   %st(3)
fstpt  -0x74(%rbp)
fmulp  %st,%st(2)
fmulp  %st,%st(2)
fsubrp %st,%st(1)
mov    %rsp,%rax
fstpt  (%rax)
mov    $0x2,%edi
call   1030 <powl@plt>
fldt   -0x74(%rbp)
fdivp  %st,%st(1)
fld1
faddp  %st,%st(1)
fnstcw -0x66(%rbp)
movzwl -0x66(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0x68(%rbp)
fldcw  -0x68(%rbp)
fistpl -0x64(%rbp)
fldcw  -0x66(%rbp)
mov    -0x64(%rbp),%edi
call   1040 <sqrtl@plt>
fld    %st(0)
fstp   %st(0)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_den>:
sub    $0x38,%rsp
fldt   0x40(%rsp)
fld    %st(0)
fstpt  0x20(%rsp)
fldt   0x80(%rsp)
fldt   0x70(%rsp)
fldt   0x60(%rsp)
fld    %st(0)
fmul   %st(1),%st
fld    %st(0)
fmul   %st(3),%st
fxch   %st(1)
fmul   %st(4),%st
fmul   %st(4),%st
fxch   %st(1)
fmul   %st(3),%st
faddp  %st,%st(1)
flds   0xea9(%rip)
fmul   %st,%st(5)
fxch   %st(5)
fmul   %st(2),%st
fmul   %st(3),%st
fldt   0x90(%rsp)
fmul   %st,%st(1)
fxch   %st(1)
faddp  %st,%st(2)
fldt   0x50(%rsp)
fmul   %st,%st(6)
fxch   %st(6)
fmulp  %st,%st(3)
fxch   %st(2)
fmul   %st(4),%st
fmul   %st(2),%st
faddp  %st,%st(1)
fldt   0x20(%rsp)
fld    %st(0)
fmul   %st(1),%st
fmul   %st(3),%st
fmul   %st(3),%st
faddp  %st,%st(2)
fld    %st(5)
fmul   %st(6),%st
fmul   %st(3),%st
fmulp  %st,%st(3)
fxch   %st(2)
faddp  %st,%st(1)
fstpt  0x2c(%rsp)
fmulp  %st,%st(2)
fmulp  %st,%st(2)
fsubrp %st,%st(1)
fstpt  (%rsp)
mov    $0x2,%edi
call   1030 <powl@plt>
fldt   0x2c(%rsp)
fdivp  %st,%st(1)
fld1
faddp  %st,%st(1)
fnstcw 0x18(%rsp)
movzwl 0x18(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x1a(%rsp)
fldcw  0x1a(%rsp)
fistpl 0x1c(%rsp)
fldcw  0x18(%rsp)
mov    0x1c(%rsp),%edi
add    $0x38,%rsp
jmp    1040 <sqrtl@plt>

LLVM IR (-O0):
define x86_fp80 @_den(x86_fp80 %0, x86_fp80 %1, x86_fp80 %2, x86_fp80 %3, x86_fp80 %4, x86_fp80 %5) {
%7 = alloca x86_fp80
%8 = alloca x86_fp80
%9 = alloca x86_fp80
%10 = alloca x86_fp80
%11 = alloca x86_fp80
%12 = alloca x86_fp80
store x86_fp80 %0, x86_fp80* %7
store x86_fp80 %1, x86_fp80* %8
store x86_fp80 %2, x86_fp80* %9
store x86_fp80 %3, x86_fp80* %10
store x86_fp80 %4, x86_fp80* %11
store x86_fp80 %5, x86_fp80* %12
%13 = load x86_fp80, x86_fp80* %9
%14 = load x86_fp80, x86_fp80* %9
%15 = fmul x86_fp80 %13, %14
%16 = load x86_fp80, x86_fp80* %10
%17 = fmul x86_fp80 %15, %16
%18 = load x86_fp80, x86_fp80* %10
%19 = load x86_fp80, x86_fp80* %9
%20 = load x86_fp80, x86_fp80* %9
%21 = fmul x86_fp80 %19, %20
%22 = load x86_fp80, x86_fp80* %11
%23 = fmul x86_fp80 %21, %22
%24 = load x86_fp80, x86_fp80* %11
%25 = fmul x86_fp80 %23, %24
%26 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %17, x86_fp80 %18, x86_fp80 %25)
%27 = load x86_fp80, x86_fp80* %7
%28 = fmul x86_fp80 0xK40008000000000000000, %27
%29 = load x86_fp80, x86_fp80* %9
%30 = fmul x86_fp80 %28, %29
%31 = load x86_fp80, x86_fp80* %10
%32 = fmul x86_fp80 %30, %31
%33 = load x86_fp80, x86_fp80* %12
%34 = fneg x86_fp80 %32
%35 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %34, x86_fp80 %33, x86_fp80 %26)
%36 = load x86_fp80, x86_fp80* %8
%37 = fmul x86_fp80 0xK40008000000000000000, %36
%38 = load x86_fp80, x86_fp80* %9
%39 = fmul x86_fp80 %37, %38
%40 = load x86_fp80, x86_fp80* %11
%41 = fmul x86_fp80 %39, %40
%42 = load x86_fp80, x86_fp80* %12
%43 = fneg x86_fp80 %41
%44 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %43, x86_fp80 %42, x86_fp80 %35)
%45 = load x86_fp80, x86_fp80* %7
%46 = load x86_fp80, x86_fp80* %7
%47 = fmul x86_fp80 %45, %46
%48 = load x86_fp80, x86_fp80* %12
%49 = fmul x86_fp80 %47, %48
%50 = load x86_fp80, x86_fp80* %12
%51 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %49, x86_fp80 %50, x86_fp80 %44)
%52 = load x86_fp80, x86_fp80* %8
%53 = load x86_fp80, x86_fp80* %8
%54 = fmul x86_fp80 %52, %53
%55 = load x86_fp80, x86_fp80* %12
%56 = fmul x86_fp80 %54, %55
%57 = load x86_fp80, x86_fp80* %12
%58 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %56, x86_fp80 %57, x86_fp80 %51)
%59 = load x86_fp80, x86_fp80* %8
%60 = load x86_fp80, x86_fp80* %10
%61 = load x86_fp80, x86_fp80* %7
%62 = load x86_fp80, x86_fp80* %11
%63 = fmul x86_fp80 %61, %62
%64 = fneg x86_fp80 %63
%65 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %59, x86_fp80 %60, x86_fp80 %64)
%66 = call x86_fp80 @powl(x86_fp80 %65, i32 2)
%67 = fdiv x86_fp80 %58, %66
%68 = fadd x86_fp80 0xK3FFF8000000000000000, %67
%69 = fptosi x86_fp80 %68 to i32
%70 = call x86_fp80 @sqrtl(i32 %69)
ret x86_fp80 %70
}

LLVM IR (-O2):
define x86_fp80 @_den(x86_fp80 %0, x86_fp80 %1, x86_fp80 %2, x86_fp80 %3, x86_fp80 %4, x86_fp80 %5) {
%7 = fmul x86_fp80 %2, %2
%8 = fmul x86_fp80 %7, %3
%9 = fmul x86_fp80 %7, %4
%10 = fmul x86_fp80 %9, %4
%11 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %8, x86_fp80 %3, x86_fp80 %10)
%12 = fmul x86_fp80 %0, 0xKC0008000000000000000
%13 = fmul x86_fp80 %12, %2
%14 = fmul x86_fp80 %13, %3
%15 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 %5, x86_fp80 %11)
%16 = fmul x86_fp80 %1, 0xKC0008000000000000000
%17 = fmul x86_fp80 %16, %2
%18 = fmul x86_fp80 %17, %4
%19 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %18, x86_fp80 %5, x86_fp80 %15)
%20 = fmul x86_fp80 %0, %0
%21 = fmul x86_fp80 %20, %5
%22 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %21, x86_fp80 %5, x86_fp80 %19)
%23 = fmul x86_fp80 %1, %1
%24 = fmul x86_fp80 %23, %5
%25 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %24, x86_fp80 %5, x86_fp80 %22)
%26 = fneg x86_fp80 %0
%27 = fmul x86_fp80 %26, %4
%28 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %1, x86_fp80 %3, x86_fp80 %27)
%29 = tail call x86_fp80 @powl(x86_fp80 %28, i32 2)
%30 = fdiv x86_fp80 %25, %29
%31 = fadd x86_fp80 %30, 0xK3FFF8000000000000000
%32 = fptosi x86_fp80 %31 to i32
%33 = tail call x86_fp80 @sqrtl(i32 %32)
ret x86_fp80 %33
}