#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 */
double fabs(double);
double log(int);
double pow(double, double);
double sqrt(double);
void ProcedureF(double k, double mu, double s, double *px, double *py,
                double *fx, double *fy) {
  static double fact[10] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
  static double a[] = {-0.5000000002, 0.3333333343, -0.2499998565, 0.1999997049,
                       -0.1666848753, 0.1428833286, -0.1241963125, 0.1101687109,
                       -0.1142650302, 0.1055093006};
  double omega, b1, b2, c0, c1, c2, c3, X;
  double mu_k = mu - k;
  if (k < 10) {
    *px = -mu;
    *py = pow(mu, k) / fact[(int)k];
  } else {
    double delta, v;
    delta = 1 / (12. * k);
    delta = delta * (1 - 4.8 * delta * delta);
    v = mu_k / k;
    if (fabs(v) <= 0.25)
      *px = mu_k * v *
                (((((((((a[9] * v + a[8]) * v + a[7]) * v + a[6]) * v + a[5]) *
                         v +
                     a[4]) *
                        v +
                    a[3]) *
                       v +
                   a[2]) *
                      v +
                  a[1]) *
                     v +
                 a[0]) -
            delta;
    else
      *px = k * log(1 + v) - mu_k - delta;
    *py = 0.3989422804014327 / sqrt(k);
  }
  omega = 0.3989422804014327 / s;
  b1 = 1 / (24. * mu);
  b2 = 0.3 * b1 * b1;
  c3 = b1 * b2 / 7.;
  c2 = b2 - 15. * c3;
  c1 = b1 - 6. * b2 + 45. * c3;
  c0 = 1. - b1 + 3. * b2 - 15. * c3;
  X = (0.5 - mu_k) / s;
  X *= X;
  *fx = -0.5 * X;
  *fy = omega * (((c3 * X + c2) * X + c1) * X + c0);
}


x86 assembly (clang, -O0):
<ProcedureF>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
mov    %rdi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
movsd  -0x10(%rbp),%xmm0
subsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xe8f(%rip),%xmm0
ucomisd -0x8(%rbp),%xmm0
jbe    11d0 <ProcedureF+0xa0>
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x10(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm1
call   1040 <pow@plt>
cvttsd2si -0x8(%rbp),%eax
movslq %eax,%rcx
lea    0x2e82(%rip),%rax
divsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1422 <ProcedureF+0x2f2>
movsd  0xe48(%rip),%xmm1
mulsd  -0x8(%rbp),%xmm1
movsd  0xe2b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0xe17(%rip),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm2
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
movsd  0xddc(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
divsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movaps 0xe1b(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xd97(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     139c <ProcedureF+0x26c>
movsd  -0x80(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  0x2e48(%rip),%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  0x2e30(%rip),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  0x2e10(%rip),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  0x2df0(%rip),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  0x2dd0(%rip),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  0x2db0(%rip),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  0x2d90(%rip),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  0x2d70(%rip),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  0x2d50(%rip),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  0x2d30(%rip),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1401 <ProcedureF+0x2d1>
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xc5f(%rip),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
cvttsd2si %xmm0,%edi
call   1030 <log@plt>
movaps %xmm0,%xmm2
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x8(%rbp),%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xc12(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  0xbfe(%rip),%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xc34(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  0xbc7(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xc0e(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  0xbe5(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  0xbaa(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  0xba3(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  0xb86(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xb31(%rip),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  0xb57(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  0xb3a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xb1d(%rip),%xmm0
subsd  -0x80(%rbp),%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xaef(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x40(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm3
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x78(%rbp),%xmm3
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x78(%rbp),%xmm3
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ProcedureF>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%rbx
movsd  %xmm2,0x28(%rsp)
movapd %xmm0,%xmm3
movapd %xmm1,%xmm9
subsd  %xmm0,%xmm9
movsd  0xe9d(%rip),%xmm0
ucomisd %xmm3,%xmm0
movapd %xmm9,0x10(%rsp)
movapd %xmm1,0x30(%rsp)
jbe    11bf <ProcedureF+0x8f>
movapd 0xf62(%rip),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rbx)
movapd %xmm1,%xmm0
movapd %xmm3,%xmm1
movsd  %xmm3,0x8(%rsp)
call   1040 <pow@plt>
movapd 0x30(%rsp),%xmm1
movapd 0x10(%rsp),%xmm9
cvttsd2si 0x8(%rsp),%eax
cltq
lea    0xf3b(%rip),%rcx
divsd  (%rcx,%rax,8),%xmm0
jmp    1316 <ProcedureF+0x1e6>
movsd  0xe41(%rip),%xmm0
mulsd  %xmm3,%xmm0
movsd  0xe3d(%rip),%xmm1
movapd %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  0xe35(%rip),%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm1,%xmm4
mulsd  %xmm2,%xmm4
movapd %xmm9,%xmm1
divsd  %xmm3,%xmm1
movapd 0xecc(%rip),%xmm0
andpd  %xmm1,%xmm0
movsd  0xe10(%rip),%xmm2
ucomisd %xmm0,%xmm2
jae    1254 <ProcedureF+0x124>
addsd  0xdf2(%rip),%xmm1
cvttsd2si %xmm1,%edi
movsd  %xmm3,0x8(%rsp)
movsd  %xmm4,0x20(%rsp)
call   1030 <log@plt>
movsd  0x8(%rsp),%xmm3
movapd 0x10(%rsp),%xmm9
mulsd  %xmm3,%xmm0
subsd  %xmm9,%xmm0
subsd  0x20(%rsp),%xmm0
jmp    12d9 <ProcedureF+0x1a9>
movsd  0xdcc(%rip),%xmm0
mulsd  %xmm1,%xmm0
addsd  0xdc8(%rip),%xmm0
mulsd  %xmm1,%xmm0
addsd  0xdc4(%rip),%xmm0
mulsd  %xmm1,%xmm0
addsd  0xdc0(%rip),%xmm0
mulsd  %xmm1,%xmm0
addsd  0xdbc(%rip),%xmm0
mulsd  %xmm1,%xmm0
addsd  0xdb8(%rip),%xmm0
movapd %xmm9,%xmm2
mulsd  %xmm1,%xmm0
addsd  0xdaf(%rip),%xmm0
mulsd  %xmm1,%xmm2
mulsd  %xmm1,%xmm0
addsd  0xda7(%rip),%xmm0
mulsd  %xmm1,%xmm0
addsd  0xda3(%rip),%xmm0
mulsd  %xmm1,%xmm0
addsd  0xd9f(%rip),%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm4,%xmm0
movsd  %xmm0,(%rbx)
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm3
jb     12f0 <ProcedureF+0x1c0>
xorps  %xmm1,%xmm1
sqrtsd %xmm3,%xmm1
jmp    1304 <ProcedureF+0x1d4>
movapd %xmm3,%xmm0
call   1050 <sqrt@plt>
movapd 0x10(%rsp),%xmm9
movapd %xmm0,%xmm1
movsd  0xd6c(%rip),%xmm0
divsd  %xmm1,%xmm0
movapd 0x30(%rsp),%xmm1
movsd  %xmm0,(%r12)
movsd  0xd54(%rip),%xmm0
movsd  0x28(%rsp),%xmm8
divsd  %xmm8,%xmm0
mulsd  0xd48(%rip),%xmm1
movsd  0xcd0(%rip),%xmm2
movapd %xmm2,%xmm3
divsd  %xmm1,%xmm3
movsd  0xd38(%rip),%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm3,%xmm1
movsd  0xd40(%rip),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
subsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm3
divsd  0xd18(%rip),%xmm3
movsd  0xd18(%rip),%xmm5
mulsd  %xmm3,%xmm5
movapd %xmm5,%xmm6
addsd  %xmm1,%xmm6
movsd  0xd14(%rip),%xmm7
mulsd  %xmm3,%xmm7
addsd  %xmm4,%xmm7
mulsd  0xd0c(%rip),%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm5,%xmm1
movsd  0xd04(%rip),%xmm2
subsd  %xmm9,%xmm2
divsd  %xmm8,%xmm2
mulsd  %xmm2,%xmm2
movsd  0xcf6(%rip),%xmm4
mulsd  %xmm2,%xmm4
movsd  %xmm4,(%r15)
mulsd  %xmm2,%xmm3
addsd  %xmm6,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm7,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%r14)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@ProcedureF.fact = internal global [10 x double] [double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 6.000000e+00, double 2.400000e+01, double 1.200000e+02, double 7.200000e+02, double 5.040000e+03, double 4.032000e+04, double 3.628800e+05]
@ProcedureF.a = internal global [10 x double] [double 0xBFE00000001B7CE0, double 0x3FD55555565F0C74, double 0xBFCFFFFECBD60A6C, double 0x3FC999971FE0A8C9, double 0xBFC555EE14135F0D, double 0x3FC24A003BBD8501, double 0xBFBFCB545C78A6DB, double 0x3FBC3404425BA47E, double 0xBFBD407917C91368, double 0x3FBB02A85380369A]
define void @ProcedureF(double %0, double %1, double %2, double* %3, double* %4, double* %5, double* %6) {
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
store double %0, double* %8
store double %1, double* %9
store double %2, double* %10
store double* %3, double** %11
store double* %4, double** %12
store double* %5, double** %13
store double* %6, double** %14
%26 = load double, double* %9
%27 = load double, double* %8
%28 = fsub double %26, %27
store double %28, double* %23
%29 = load double, double* %8
%30 = fcmp olt double %29, 1.000000e+01
br i1 %30, label %31, label %45
31: ; preds = %7
%32 = load double, double* %9
%33 = fneg double %32
%34 = load double*, double** %11
store double %33, double* %34
%35 = load double, double* %9
%36 = load double, double* %8
%37 = call double @pow(double %35, double %36)
%38 = load double, double* %8
%39 = fptosi double %38 to i32
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [10 x double], [10 x double]* @ProcedureF.fact, i64 0, i64 %40
%42 = load double, double* %41
%43 = fdiv double %37, %42
%44 = load double*, double** %12
store double %43, double* %44
br label %115
45: ; preds = %7
%46 = load double, double* %8
%47 = fmul double 1.200000e+01, %46
%48 = fdiv double 1.000000e+00, %47
store double %48, double* %24
%49 = load double, double* %24
%50 = load double, double* %24
%51 = fmul double 4.800000e+00, %50
%52 = load double, double* %24
%53 = fneg double %51
%54 = call double @llvm.fmuladd.f64(double %53, double %52, double 1.000000e+00)
%55 = fmul double %49, %54
store double %55, double* %24
%56 = load double, double* %23
%57 = load double, double* %8
%58 = fdiv double %56, %57
store double %58, double* %25
%59 = load double, double* %25
%60 = call double @llvm.fabs.f64(double %59)
%61 = fcmp ole double %60, 2.500000e-01
br i1 %61, label %62, label %98
62: ; preds = %45
%63 = load double, double* %23
%64 = load double, double* %25
%65 = fmul double %63, %64
%66 = load double, double* getelementptr inbounds ([10 x double], [10 x double]* @ProcedureF.a, i64 0, i64 9)
%67 = load double, double* %25
%68 = load double, double* getelementptr inbounds ([10 x double], [10 x double]* @ProcedureF.a, i64 0, i64 8)
%69 = call double @llvm.fmuladd.f64(double %66, double %67, double %68)
%70 = load double, double* %25
%71 = load double, double* getelementptr inbounds ([10 x double], [10 x double]* @ProcedureF.a, i64 0, i64 7)
%72 = call double @llvm.fmuladd.f64(double %69, double %70, double %71)
%73 = load double, double* %25
%74 = load double, double* getelementptr inbounds ([10 x double], [10 x double]* @ProcedureF.a, i64 0, i64 6)
%75 = call double @llvm.fmuladd.f64(double %72, double %73, double %74)
%76 = load double, double* %25
%77 = load double, double* getelementptr inbounds ([10 x double], [10 x double]* @ProcedureF.a, i64 0, i64 5)
%78 = call double @llvm.fmuladd.f64(double %75, double %76, double %77)
%79 = load double, double* %25
%80 = load double, double* getelementptr inbounds ([10 x double], [10 x double]* @ProcedureF.a, i64 0, i64 4)
%81 = call double @llvm.fmuladd.f64(double %78, double %79, double %80)
%82 = load double, double* %25
%83 = load double, double* getelementptr inbounds ([10 x double], [10 x double]* @ProcedureF.a, i64 0, i64 3)
%84 = call double @llvm.fmuladd.f64(double %81, double %82, double %83)
%85 = load double, double* %25
%86 = load double, double* getelementptr inbounds ([10 x double], [10 x double]* @ProcedureF.a, i64 0, i64 2)
%87 = call double @llvm.fmuladd.f64(double %84, double %85, double %86)
%88 = load double, double* %25
%89 = load double, double* getelementptr inbounds ([10 x double], [10 x double]* @ProcedureF.a, i64 0, i64 1)
%90 = call double @llvm.fmuladd.f64(double %87, double %88, double %89)
%91 = load double, double* %25
%92 = load double, double* getelementptr inbounds ([10 x double], [10 x double]* @ProcedureF.a, i64 0, i64 0)
%93 = call double @llvm.fmuladd.f64(double %90, double %91, double %92)
%94 = load double, double* %24
%95 = fneg double %94
%96 = call double @llvm.fmuladd.f64(double %65, double %93, double %95)
%97 = load double*, double** %11
store double %96, double* %97
br label %110
98: ; preds = %45
%99 = load double, double* %8
%100 = load double, double* %25
%101 = fadd double 1.000000e+00, %100
%102 = fptosi double %101 to i32
%103 = call double @log(i32 %102)
%104 = load double, double* %23
%105 = fneg double %104
%106 = call double @llvm.fmuladd.f64(double %99, double %103, double %105)
%107 = load double, double* %24
%108 = fsub double %106, %107
%109 = load double*, double** %11
store double %108, double* %109
br label %110
110: ; preds = %98, %62
%111 = load double, double* %8
%112 = call double @sqrt(double %111)
%113 = fdiv double 0x3FD9884533D43651, %112
%114 = load double*, double** %12
store double %113, double* %114
br label %115
115: ; preds = %110, %31
%116 = load double, double* %10
%117 = fdiv double 0x3FD9884533D43651, %116
store double %117, double* %15
%118 = load double, double* %9
%119 = fmul double 2.400000e+01, %118
%120 = fdiv double 1.000000e+00, %119
store double %120, double* %16
%121 = load double, double* %16
%122 = fmul double 3.000000e-01, %121
%123 = load double, double* %16
%124 = fmul double %122, %123
store double %124, double* %17
%125 = load double, double* %16
%126 = load double, double* %17
%127 = fmul double %125, %126
%128 = fdiv double %127, 7.000000e+00
store double %128, double* %21
%129 = load double, double* %17
%130 = load double, double* %21
%131 = call double @llvm.fmuladd.f64(double -1.500000e+01, double %130, double %129)
store double %131, double* %20
%132 = load double, double* %16
%133 = load double, double* %17
%134 = call double @llvm.fmuladd.f64(double -6.000000e+00, double %133, double %132)
%135 = load double, double* %21
%136 = call double @llvm.fmuladd.f64(double 4.500000e+01, double %135, double %134)
store double %136, double* %19
%137 = load double, double* %16
%138 = fsub double 1.000000e+00, %137
%139 = load double, double* %17
%140 = call double @llvm.fmuladd.f64(double 3.000000e+00, double %139, double %138)
%141 = load double, double* %21
%142 = call double @llvm.fmuladd.f64(double -1.500000e+01, double %141, double %140)
store double %142, double* %18
%143 = load double, double* %23
%144 = fsub double 5.000000e-01, %143
%145 = load double, double* %10
%146 = fdiv double %144, %145
store double %146, double* %22
%147 = load double, double* %22
%148 = load double, double* %22
%149 = fmul double %148, %147
store double %149, double* %22
%150 = load double, double* %22
%151 = fmul double -5.000000e-01, %150
%152 = load double*, double** %13
store double %151, double* %152
%153 = load double, double* %15
%154 = load double, double* %21
%155 = load double, double* %22
%156 = load double, double* %20
%157 = call double @llvm.fmuladd.f64(double %154, double %155, double %156)
%158 = load double, double* %22
%159 = load double, double* %19
%160 = call double @llvm.fmuladd.f64(double %157, double %158, double %159)
%161 = load double, double* %22
%162 = load double, double* %18
%163 = call double @llvm.fmuladd.f64(double %160, double %161, double %162)
%164 = fmul double %153, %163
%165 = load double*, double** %14
store double %164, double* %165
ret void
}

LLVM IR (-O2):
@ProcedureF.fact = internal unnamed_addr constant [10 x double] [double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 6.000000e+00, double 2.400000e+01, double 1.200000e+02, double 7.200000e+02, double 5.040000e+03, double 4.032000e+04, double 3.628800e+05]
define void @ProcedureF(double %0, double %1, double %2, double* nocapture writeonly %3, double* nocapture writeonly %4, double* nocapture writeonly %5, double* nocapture writeonly %6) {
%8 = fsub double %1, %0
%9 = fcmp olt double %0, 1.000000e+01
br i1 %9, label %10, label %18
10: ; preds = %7
%11 = fneg double %1
store double %11, double* %3
%12 = tail call double @pow(double %1, double %0)
%13 = fptosi double %0 to i32
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds [10 x double], [10 x double]* @ProcedureF.fact, i64 0, i64 %14
%16 = load double, double* %15
%17 = fdiv double %12, %16
br label %51
18: ; preds = %7
%19 = fmul double %0, 1.200000e+01
%20 = fdiv double 1.000000e+00, %19
%21 = fmul double %20, -4.800000e+00
%22 = tail call double @llvm.fmuladd.f64(double %21, double %20, double 1.000000e+00)
%23 = fmul double %20, %22
%24 = fdiv double %8, %0
%25 = tail call double @llvm.fabs.f64(double %24)
%26 = fcmp ugt double %25, 2.500000e-01
br i1 %26, label %40, label %27
27: ; preds = %18
%28 = fmul double %8, %24
%29 = tail call double @llvm.fmuladd.f64(double %24, double 0x3FBB02A85380369A, double 0xBFBD407917C91368)
%30 = tail call double @llvm.fmuladd.f64(double %29, double %24, double 0x3FBC3404425BA47E)
%31 = tail call double @llvm.fmuladd.f64(double %30, double %24, double 0xBFBFCB545C78A6DB)
%32 = tail call double @llvm.fmuladd.f64(double %31, double %24, double 0x3FC24A003BBD8501)
%33 = tail call double @llvm.fmuladd.f64(double %32, double %24, double 0xBFC555EE14135F0D)
%34 = tail call double @llvm.fmuladd.f64(double %33, double %24, double 0x3FC999971FE0A8C9)
%35 = tail call double @llvm.fmuladd.f64(double %34, double %24, double 0xBFCFFFFECBD60A6C)
%36 = tail call double @llvm.fmuladd.f64(double %35, double %24, double 0x3FD55555565F0C74)
%37 = tail call double @llvm.fmuladd.f64(double %36, double %24, double 0xBFE00000001B7CE0)
%38 = fneg double %23
%39 = tail call double @llvm.fmuladd.f64(double %28, double %37, double %38)
br label %47
40: ; preds = %18
%41 = fadd double %24, 1.000000e+00
%42 = fptosi double %41 to i32
%43 = tail call double @log(i32 %42)
%44 = fneg double %8
%45 = tail call double @llvm.fmuladd.f64(double %0, double %43, double %44)
%46 = fsub double %45, %23
br label %47
47: ; preds = %40, %27
%48 = phi double [ %46, %40 ], [ %39, %27 ]
store double %48, double* %3
%49 = tail call double @sqrt(double %0)
%50 = fdiv double 0x3FD9884533D43651, %49
br label %51
51: ; preds = %47, %10
%52 = phi double [ %50, %47 ], [ %17, %10 ]
store double %52, double* %4
%53 = fdiv double 0x3FD9884533D43651, %2
%54 = fmul double %1, 2.400000e+01
%55 = fdiv double 1.000000e+00, %54
%56 = fmul double %55, 3.000000e-01
%57 = fmul double %55, %56
%58 = fmul double %55, %57
%59 = fdiv double %58, 7.000000e+00
%60 = tail call double @llvm.fmuladd.f64(double %59, double -1.500000e+01, double %57)
%61 = tail call double @llvm.fmuladd.f64(double %57, double -6.000000e+00, double %55)
%62 = tail call double @llvm.fmuladd.f64(double %59, double 4.500000e+01, double %61)
%63 = fsub double 1.000000e+00, %55
%64 = tail call double @llvm.fmuladd.f64(double %57, double 3.000000e+00, double %63)
%65 = tail call double @llvm.fmuladd.f64(double %59, double -1.500000e+01, double %64)
%66 = fsub double 5.000000e-01, %8
%67 = fdiv double %66, %2
%68 = fmul double %67, %67
%69 = fmul double %68, -5.000000e-01
store double %69, double* %5
%70 = tail call double @llvm.fmuladd.f64(double %59, double %68, double %60)
%71 = tail call double @llvm.fmuladd.f64(double %70, double %68, double %62)
%72 = tail call double @llvm.fmuladd.f64(double %71, double %68, double %65)
%73 = fmul double %53, %72
store double %73, double* %6
ret void
}