#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 exp(long double const);
double tanh(long double const);
long double stepfunc(long double time, const long double *p,
                     long double maxlength, long double maxstep,
                     long double maxbaseline, long double risetime, int sign) {
  long double sigma1, sigma2, a, b;
  long double t1 = maxlength / 2.0 * (1.0 + tanh(p[2]));
  long double t2 = maxlength / 2.0 * (1.0 + tanh(p[5]));
  long double fitval = sign * maxbaseline / 2.0 * (1.0 + tanh(p[0]));
  if (time > t1) {
    sigma1 = risetime * exp(p[3]);
    a = sign * maxstep / 2.0 * (1.0 + tanh(p[1]));
    fitval -= a * (1.0 - exp(-(time - t1) / sigma1));
  }
  if (time > t2) {
    sigma2 = risetime * exp(p[6]);
    b = sign * maxstep / 2.0 * (1.0 + tanh(p[4]));
    fitval += b * (1.0 - exp(-(time - t2) / sigma2));
  }
  return fitval;
}


x86 assembly (clang, -O0):
<stepfunc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1f0,%rsp
fldt   0x50(%rbp)
fldt   0x40(%rbp)
fldt   0x30(%rbp)
fldt   0x20(%rbp)
fldt   0x10(%rbp)
fstpt  -0x10(%rbp)
mov    %rdi,-0x18(%rbp)
fstpt  -0x30(%rbp)
fstpt  -0x40(%rbp)
fstpt  -0x50(%rbp)
fstpt  -0x60(%rbp)
mov    %esi,-0x64(%rbp)
fldt   -0x30(%rbp)
flds   0xea7(%rip)
fld    %st(0)
fstpt  -0x164(%rbp)
fdivrp %st,%st(1)
fstpt  -0x17c(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x20(%rax)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <tanh@plt>
fldt   -0x17c(%rbp)
fldt   -0x164(%rbp)
movsd  0xe7a(%rip),%xmm1
movsd  %xmm1,-0x158(%rbp)
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
fldl   -0xf0(%rbp)
fmulp  %st,%st(2)
fxch   %st(1)
fstpt  -0xc0(%rbp)
fldt   -0x30(%rbp)
fdivp  %st,%st(1)
fstpt  -0x170(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x50(%rax)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <tanh@plt>
fldt   -0x170(%rbp)
fldt   -0x164(%rbp)
movsd  -0x158(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
fldl   -0xf8(%rbp)
fmulp  %st,%st(2)
fxch   %st(1)
fstpt  -0xd0(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0xe4(%rbp)
fildl  -0xe4(%rbp)
fldt   -0x50(%rbp)
fmulp  %st,%st(1)
fdivp  %st,%st(1)
fstpt  -0x14c(%rbp)
mov    -0x18(%rbp),%rax
fldt   (%rax)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <tanh@plt>
movsd  -0x158(%rbp),%xmm1
ff
fldt   -0x14c(%rbp)
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
fldl   -0x100(%rbp)
fmulp  %st,%st(1)
fstpt  -0xe0(%rbp)
fldt   -0x10(%rbp)
fldt   -0xc0(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jbe    135f <stepfunc+0x23f>
jmp    126c <stepfunc+0x14c>
fldt   -0x60(%rbp)
fstpt  -0x1ac(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x30(%rax)
mov    %rsp,%rax
fstpt  (%rax)
call   1040 <exp@plt>
fldt   -0x1ac(%rbp)
movsd  %xmm0,-0x110(%rbp)
ff
fldl   -0x110(%rbp)
fmulp  %st,%st(1)
fstpt  -0x80(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x104(%rbp)
fildl  -0x104(%rbp)
fldt   -0x40(%rbp)
fmulp  %st,%st(1)
flds   0xd47(%rip)
fdivrp %st,%st(1)
fstpt  -0x1a0(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x10(%rax)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <tanh@plt>
fldt   -0x1a0(%rbp)
movsd  0xd28(%rip),%xmm1
movsd  %xmm1,-0x188(%rbp)
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
fldl   -0x118(%rbp)
fmulp  %st,%st(1)
fstpt  -0xa0(%rbp)
fldt   -0xa0(%rbp)
fstpt  -0x194(%rbp)
fldt   -0x10(%rbp)
fldt   -0xc0(%rbp)
fsubrp %st,%st(1)
fchs
fldt   -0x80(%rbp)
fdivrp %st,%st(1)
mov    %rsp,%rax
fstpt  (%rax)
call   1040 <exp@plt>
fldt   -0x194(%rbp)
movaps %xmm0,%xmm1
movsd  -0x188(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
fldl   -0x120(%rbp)
fldt   -0xe0(%rbp)
fxch   %st(2)
fmulp  %st,%st(1)
fsubrp %st,%st(1)
fstpt  -0xe0(%rbp)
fldt   -0x10(%rbp)
fldt   -0xd0(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jbe    1472 <stepfunc+0x352>
jmp    1379 <stepfunc+0x259>
fldt   -0x60(%rbp)
fstpt  -0x1dc(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x60(%rax)
mov    %rsp,%rax
fstpt  (%rax)
call   1040 <exp@plt>
fldt   -0x1dc(%rbp)
movsd  %xmm0,-0x130(%rbp)
ff
fldl   -0x130(%rbp)
fmulp  %st,%st(1)
fstpt  -0x90(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x124(%rbp)
fildl  -0x124(%rbp)
fldt   -0x40(%rbp)
fmulp  %st,%st(1)
flds   0xc37(%rip)
fdivrp %st,%st(1)
fstpt  -0x1d0(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x40(%rax)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <tanh@plt>
fldt   -0x1d0(%rbp)
movsd  0xc18(%rip),%xmm1
movsd  %xmm1,-0x1b8(%rbp)
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
fldl   -0x138(%rbp)
fmulp  %st,%st(1)
fstpt  -0xb0(%rbp)
fldt   -0xb0(%rbp)
fstpt  -0x1c4(%rbp)
fldt   -0x10(%rbp)
fldt   -0xd0(%rbp)
fsubrp %st,%st(1)
fchs
fldt   -0x90(%rbp)
fdivrp %st,%st(1)
mov    %rsp,%rax
fstpt  (%rax)
call   1040 <exp@plt>
fldt   -0x1c4(%rbp)
movaps %xmm0,%xmm1
movsd  -0x1b8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
fldl   -0x140(%rbp)
fldt   -0xe0(%rbp)
fxch   %st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0xe0(%rbp)
fldt   -0xe0(%rbp)
add    $0x1f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stepfunc>:
push   %rbp
push   %rbx
sub    $0xd8,%rsp
mov    %esi,%ebp
mov    %rdi,%rbx
fldt   0x130(%rsp)
fstpt  0x34(%rsp)
fldt   0x110(%rsp)
fstpt  0x28(%rsp)
fldt   0xf0(%rsp)
fstpt  0x4c(%rsp)
fldt   0x120(%rsp)
fstpt  0x1c(%rsp)
fldt   0x100(%rsp)
flds   0xe99(%rip)
fld    %st(0)
fstpt  0x5c(%rsp)
fmulp  %st,%st(1)
fstpt  0x40(%rsp)
fldt   0x20(%rdi)
fstpt  (%rsp)
call   1030 <tanh@plt>
addsd  0xe82(%rip),%xmm0
movsd  %xmm0,0xc0(%rsp)
fldt   0x40(%rsp)
fmull  0xc0(%rsp)
fstpt  0x74(%rsp)
fldt   0x50(%rbx)
fstpt  (%rsp)
call   1030 <tanh@plt>
addsd  0xe57(%rip),%xmm0
movsd  %xmm0,0xb8(%rsp)
fldt   0x40(%rsp)
fmull  0xb8(%rsp)
fstpt  0x40(%rsp)
mov    %ebp,0x58(%rsp)
fildl  0x58(%rsp)
fldt   0x1c(%rsp)
fld    %st(1)
fstpt  0x68(%rsp)
fmulp  %st,%st(1)
fldt   0x5c(%rsp)
fmulp  %st,%st(1)
fstpt  0x1c(%rsp)
fldt   (%rbx)
fstpt  (%rsp)
call   1030 <tanh@plt>
fldt   0x4c(%rsp)
addsd  0xe0b(%rip),%xmm0
movsd  %xmm0,0xb0(%rsp)
fldt   0x1c(%rsp)
fmull  0xb0(%rsp)
fldt   0x74(%rsp)
fxch   %st(2)
fucomi %st(2),%st
fstp   %st(2)
jbe    12cd <stepfunc+0x1ad>
fstp   %st(1)
fldt   0x30(%rbx)
fstpt  (%rsp)
fstpt  0x1c(%rsp)
call   1040 <exp@plt>
movsd  %xmm0,0xa8(%rsp)
fldt   0x34(%rsp)
fmull  0xa8(%rsp)
fstpt  0xcc(%rsp)
fldt   0x28(%rsp)
fldt   0x68(%rsp)
fmulp  %st,%st(1)
fstpt  0x5c(%rsp)
fldt   0x10(%rbx)
fstpt  (%rsp)
call   1030 <tanh@plt>
addsd  0xd9a(%rip),%xmm0
movsd  %xmm0,0xa0(%rsp)
fldt   0x4c(%rsp)
fldt   0x74(%rsp)
fsubrp %st,%st(1)
fchs
fldt   0xcc(%rsp)
fdivrp %st,%st(1)
fstpt  (%rsp)
call   1040 <exp@plt>
fldt   0x1c(%rsp)
movsd  0xd68(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x98(%rsp)
fldt   0x5c(%rsp)
fmuls  0xd4d(%rip)
fmull  0xa0(%rsp)
fmull  0x98(%rsp)
faddp  %st,%st(1)
fldt   0x4c(%rsp)
jmp    12e1 <stepfunc+0x1c1>
fldt   0x68(%rsp)
fstp   %st(0)
fldt   0x34(%rsp)
fstp   %st(0)
fldt   0x28(%rsp)
fstp   %st(0)
fxch   %st(1)
fldt   0x40(%rsp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jbe    139b <stepfunc+0x27b>
fldt   0x60(%rbx)
fstpt  (%rsp)
fstpt  0x1c(%rsp)
call   1040 <exp@plt>
movsd  %xmm0,0x90(%rsp)
fldt   0x34(%rsp)
fmull  0x90(%rsp)
fstpt  0x34(%rsp)
fldt   0x28(%rsp)
fldt   0x68(%rsp)
fmulp  %st,%st(1)
fmuls  0xcd8(%rip)
fstpt  0x28(%rsp)
fldt   0x40(%rbx)
fstpt  (%rsp)
call   1030 <tanh@plt>
movsd  0xcc9(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x88(%rsp)
fldt   0x28(%rsp)
fmull  0x88(%rsp)
fstpt  0x28(%rsp)
fldt   0x4c(%rsp)
fldt   0x40(%rsp)
fsubrp %st,%st(1)
fchs
fldt   0x34(%rsp)
fdivrp %st,%st(1)
fstpt  (%rsp)
call   1040 <exp@plt>
movsd  0xc8b(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x80(%rsp)
fldt   0x28(%rsp)
fmull  0x80(%rsp)
fldt   0x1c(%rsp)
faddp  %st,%st(1)
add    $0xd8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define x86_fp80 @stepfunc(x86_fp80 %0, x86_fp80* %1, x86_fp80 %2, x86_fp80 %3, x86_fp80 %4, x86_fp80 %5, i32 %6) {
%8 = alloca x86_fp80
%9 = alloca x86_fp80*
%10 = alloca x86_fp80
%11 = alloca x86_fp80
%12 = alloca x86_fp80
%13 = alloca x86_fp80
%14 = alloca i32
%15 = alloca x86_fp80
%16 = alloca x86_fp80
%17 = alloca x86_fp80
%18 = alloca x86_fp80
%19 = alloca x86_fp80
%20 = alloca x86_fp80
%21 = alloca x86_fp80
store x86_fp80 %0, x86_fp80* %8
store x86_fp80* %1, x86_fp80** %9
store x86_fp80 %2, x86_fp80* %10
store x86_fp80 %3, x86_fp80* %11
store x86_fp80 %4, x86_fp80* %12
store x86_fp80 %5, x86_fp80* %13
store i32 %6, i32* %14
%22 = load x86_fp80, x86_fp80* %10
%23 = fdiv x86_fp80 %22, 0xK40008000000000000000
%24 = load x86_fp80*, x86_fp80** %9
%25 = getelementptr inbounds x86_fp80, x86_fp80* %24, i64 2
%26 = load x86_fp80, x86_fp80* %25
%27 = call double @tanh(x86_fp80 %26)
%28 = fadd double 1.000000e+00, %27
%29 = fpext double %28 to x86_fp80
%30 = fmul x86_fp80 %23, %29
store x86_fp80 %30, x86_fp80* %19
%31 = load x86_fp80, x86_fp80* %10
%32 = fdiv x86_fp80 %31, 0xK40008000000000000000
%33 = load x86_fp80*, x86_fp80** %9
%34 = getelementptr inbounds x86_fp80, x86_fp80* %33, i64 5
%35 = load x86_fp80, x86_fp80* %34
%36 = call double @tanh(x86_fp80 %35)
%37 = fadd double 1.000000e+00, %36
%38 = fpext double %37 to x86_fp80
%39 = fmul x86_fp80 %32, %38
store x86_fp80 %39, x86_fp80* %20
%40 = load i32, i32* %14
%41 = sitofp i32 %40 to x86_fp80
%42 = load x86_fp80, x86_fp80* %12
%43 = fmul x86_fp80 %41, %42
%44 = fdiv x86_fp80 %43, 0xK40008000000000000000
%45 = load x86_fp80*, x86_fp80** %9
%46 = getelementptr inbounds x86_fp80, x86_fp80* %45, i64 0
%47 = load x86_fp80, x86_fp80* %46
%48 = call double @tanh(x86_fp80 %47)
%49 = fadd double 1.000000e+00, %48
%50 = fpext double %49 to x86_fp80
%51 = fmul x86_fp80 %44, %50
store x86_fp80 %51, x86_fp80* %21
%52 = load x86_fp80, x86_fp80* %8
%53 = load x86_fp80, x86_fp80* %19
%54 = fcmp ogt x86_fp80 %52, %53
br i1 %54, label %55, label %88
55: ; preds = %7
%56 = load x86_fp80, x86_fp80* %13
%57 = load x86_fp80*, x86_fp80** %9
%58 = getelementptr inbounds x86_fp80, x86_fp80* %57, i64 3
%59 = load x86_fp80, x86_fp80* %58
%60 = call double @exp(x86_fp80 %59)
%61 = fpext double %60 to x86_fp80
%62 = fmul x86_fp80 %56, %61
store x86_fp80 %62, x86_fp80* %15
%63 = load i32, i32* %14
%64 = sitofp i32 %63 to x86_fp80
%65 = load x86_fp80, x86_fp80* %11
%66 = fmul x86_fp80 %64, %65
%67 = fdiv x86_fp80 %66, 0xK40008000000000000000
%68 = load x86_fp80*, x86_fp80** %9
%69 = getelementptr inbounds x86_fp80, x86_fp80* %68, i64 1
%70 = load x86_fp80, x86_fp80* %69
%71 = call double @tanh(x86_fp80 %70)
%72 = fadd double 1.000000e+00, %71
%73 = fpext double %72 to x86_fp80
%74 = fmul x86_fp80 %67, %73
store x86_fp80 %74, x86_fp80* %17
%75 = load x86_fp80, x86_fp80* %17
%76 = load x86_fp80, x86_fp80* %8
%77 = load x86_fp80, x86_fp80* %19
%78 = fsub x86_fp80 %76, %77
%79 = fneg x86_fp80 %78
%80 = load x86_fp80, x86_fp80* %15
%81 = fdiv x86_fp80 %79, %80
%82 = call double @exp(x86_fp80 %81)
%83 = fsub double 1.000000e+00, %82
%84 = fpext double %83 to x86_fp80
%85 = load x86_fp80, x86_fp80* %21
%86 = fneg x86_fp80 %75
%87 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %86, x86_fp80 %84, x86_fp80 %85)
store x86_fp80 %87, x86_fp80* %21
br label %88
88: ; preds = %55, %7
%89 = load x86_fp80, x86_fp80* %8
%90 = load x86_fp80, x86_fp80* %20
%91 = fcmp ogt x86_fp80 %89, %90
br i1 %91, label %92, label %124
92: ; preds = %88
%93 = load x86_fp80, x86_fp80* %13
%94 = load x86_fp80*, x86_fp80** %9
%95 = getelementptr inbounds x86_fp80, x86_fp80* %94, i64 6
%96 = load x86_fp80, x86_fp80* %95
%97 = call double @exp(x86_fp80 %96)
%98 = fpext double %97 to x86_fp80
%99 = fmul x86_fp80 %93, %98
store x86_fp80 %99, x86_fp80* %16
%100 = load i32, i32* %14
%101 = sitofp i32 %100 to x86_fp80
%102 = load x86_fp80, x86_fp80* %11
%103 = fmul x86_fp80 %101, %102
%104 = fdiv x86_fp80 %103, 0xK40008000000000000000
%105 = load x86_fp80*, x86_fp80** %9
%106 = getelementptr inbounds x86_fp80, x86_fp80* %105, i64 4
%107 = load x86_fp80, x86_fp80* %106
%108 = call double @tanh(x86_fp80 %107)
%109 = fadd double 1.000000e+00, %108
%110 = fpext double %109 to x86_fp80
%111 = fmul x86_fp80 %104, %110
store x86_fp80 %111, x86_fp80* %18
%112 = load x86_fp80, x86_fp80* %18
%113 = load x86_fp80, x86_fp80* %8
%114 = load x86_fp80, x86_fp80* %20
%115 = fsub x86_fp80 %113, %114
%116 = fneg x86_fp80 %115
%117 = load x86_fp80, x86_fp80* %16
%118 = fdiv x86_fp80 %116, %117
%119 = call double @exp(x86_fp80 %118)
%120 = fsub double 1.000000e+00, %119
%121 = fpext double %120 to x86_fp80
%122 = load x86_fp80, x86_fp80* %21
%123 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %112, x86_fp80 %121, x86_fp80 %122)
store x86_fp80 %123, x86_fp80* %21
br label %124
124: ; preds = %92, %88
%125 = load x86_fp80, x86_fp80* %21
ret x86_fp80 %125
}

LLVM IR (-O2):
define x86_fp80 @stepfunc(x86_fp80 %0, x86_fp80* nocapture %1, x86_fp80 %2, x86_fp80 %3, x86_fp80 %4, x86_fp80 %5, i32 %6) {
%8 = fmul x86_fp80 %2, 0xK3FFE8000000000000000
%9 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 2
%10 = load x86_fp80, x86_fp80* %9
%11 = tail call double @tanh(x86_fp80 %10)
%12 = fadd double %11, 1.000000e+00
%13 = fpext double %12 to x86_fp80
%14 = fmul x86_fp80 %8, %13
%15 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 5
%16 = load x86_fp80, x86_fp80* %15
%17 = tail call double @tanh(x86_fp80 %16)
%18 = fadd double %17, 1.000000e+00
%19 = fpext double %18 to x86_fp80
%20 = fmul x86_fp80 %8, %19
%21 = sitofp i32 %6 to x86_fp80
%22 = fmul x86_fp80 %21, %4
%23 = fmul x86_fp80 %22, 0xK3FFE8000000000000000
%24 = load x86_fp80, x86_fp80* %1
%25 = tail call double @tanh(x86_fp80 %24)
%26 = fadd double %25, 1.000000e+00
%27 = fpext double %26 to x86_fp80
%28 = fmul x86_fp80 %23, %27
%29 = fcmp olt x86_fp80 %14, %0
br i1 %29, label %30, label %51
30: ; preds = %7
%31 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 3
%32 = load x86_fp80, x86_fp80* %31
%33 = tail call double @exp(x86_fp80 %32)
%34 = fpext double %33 to x86_fp80
%35 = fmul x86_fp80 %34, %5
%36 = fmul x86_fp80 %21, %3
%37 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 1
%38 = load x86_fp80, x86_fp80* %37
%39 = tail call double @tanh(x86_fp80 %38)
%40 = fadd double %39, 1.000000e+00
%41 = fpext double %40 to x86_fp80
%42 = fsub x86_fp80 %0, %14
%43 = fneg x86_fp80 %42
%44 = fdiv x86_fp80 %43, %35
%45 = tail call double @exp(x86_fp80 %44)
%46 = fsub double 1.000000e+00, %45
%47 = fpext double %46 to x86_fp80
%48 = fmul x86_fp80 %36, 0xKBFFE8000000000000000
%49 = fmul x86_fp80 %48, %41
%50 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %49, x86_fp80 %47, x86_fp80 %28)
br label %51
51: ; preds = %30, %7
%52 = phi x86_fp80 [ %50, %30 ], [ %28, %7 ]
%53 = fcmp olt x86_fp80 %20, %0
br i1 %53, label %54, label %75
54: ; preds = %51
%55 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 6
%56 = load x86_fp80, x86_fp80* %55
%57 = tail call double @exp(x86_fp80 %56)
%58 = fpext double %57 to x86_fp80
%59 = fmul x86_fp80 %58, %5
%60 = fmul x86_fp80 %21, %3
%61 = fmul x86_fp80 %60, 0xK3FFE8000000000000000
%62 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 4
%63 = load x86_fp80, x86_fp80* %62
%64 = tail call double @tanh(x86_fp80 %63)
%65 = fadd double %64, 1.000000e+00
%66 = fpext double %65 to x86_fp80
%67 = fmul x86_fp80 %61, %66
%68 = fsub x86_fp80 %0, %20
%69 = fneg x86_fp80 %68
%70 = fdiv x86_fp80 %69, %59
%71 = tail call double @exp(x86_fp80 %70)
%72 = fsub double 1.000000e+00, %71
%73 = fpext double %72 to x86_fp80
%74 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %67, x86_fp80 %73, x86_fp80 %52)
br label %75
75: ; preds = %54, %51
%76 = phi x86_fp80 [ %74, %54 ], [ %52, %51 ]
ret x86_fp80 %76
}