#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 */
scalar_t__ exp(double);
double fabs(double);
scalar_t__ log(double);
double IncompleteGamma(double x, double alpha, double ln_gamma_alpha) {
  int i;
  double p = alpha, g = ln_gamma_alpha;
  double accurate = 1e-8, overflow = 1e30;
  double factor, gin = 0, rn = 0, a = 0, b = 0, an = 0, dif = 0, term = 0,
                 pn[6];
  if (x == 0)
    return (0);
  if (x < 0 || p <= 0)
    return (-1);
  factor = (double)exp(p * (double)log(x) - x - g);
  if (x > 1 && x >= p)
    goto l30;
  gin = 1;
  term = 1;
  rn = p;
l20:
  rn++;
  term *= x / rn;
  gin += term;
  if (term > accurate)
    goto l20;
  gin *= factor / p;
  goto l50;
l30:
  a = 1 - p;
  b = a + x + 1;
  term = 0;
  pn[0] = 1;
  pn[1] = x;
  pn[2] = x + 1;
  pn[3] = x * b;
  gin = pn[2] / pn[3];
l32:
  a++;
  b += 2;
  term++;
  an = a * term;
  for (i = 0; i < 2; i++)
    pn[i + 4] = b * pn[i + 2] - an * pn[i];
  if (pn[5] == 0)
    goto l35;
  rn = pn[4] / pn[5];
  dif = fabs(gin - rn);
  if (dif > accurate)
    goto l34;
  if (dif <= accurate * rn)
    goto l42;
l34:
  gin = rn;
l35:
  for (i = 0; i < 4; i++)
    pn[i] = pn[i + 2];
  if (fabs(pn[4]) < overflow)
    goto l32;
  for (i = 0; i < 4; i++)
    pn[i] /= overflow;
  goto l32;
l42:
  gin = 1 - factor * gin;
l50:
  return (gin);
}


x86 assembly (clang, -O0):
<IncompleteGamma>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xeb2(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xe9d(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11c8 <IncompleteGamma+0xa8>
jp     11c8 <IncompleteGamma+0xa8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    15e2 <IncompleteGamma+0x4c2>
xorps  %xmm0,%xmm0
ucomisd -0x10(%rbp),%xmm0
ja     11e4 <IncompleteGamma+0xc4>
xorps  %xmm0,%xmm0
ucomisd -0x30(%rbp),%xmm0
jb     11f6 <IncompleteGamma+0xd6>
movsd  0xe34(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    15e2 <IncompleteGamma+0x4c2>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
call   1040 <log@plt>
movsd  -0xc8(%rbp),%xmm0
ff
cvtsi2sd %rax,%xmm2
movsd  -0x10(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x38(%rbp),%xmm0
call   1030 <exp@plt>
cvtsi2sd %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  0xdb1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    127e <IncompleteGamma+0x15e>
movsd  -0x10(%rbp),%xmm0
ucomisd -0x30(%rbp),%xmm0
jb     127e <IncompleteGamma+0x15e>
jmp    1314 <IncompleteGamma+0x1f4>
movsd  0xd8a(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xd7d(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xd63(%rip),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x10(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0x40(%rbp),%xmm0
jbe    12fb <IncompleteGamma+0x1db>
jmp    12a5 <IncompleteGamma+0x185>
movsd  -0x50(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    15d8 <IncompleteGamma+0x4b8>
movsd  0xcf4(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
addsd  -0x10(%rbp),%xmm0
movsd  0xcd8(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xcbc(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xc9f(%rip),%xmm0
addsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  0xc63(%rip),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0xc59(%rip),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xc3f(%rip),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x2,-0x24(%rbp)
jge    146a <IncompleteGamma+0x34a>
movsd  -0x70(%rbp),%xmm0
mov    -0x24(%rbp),%eax
add    $0x2,%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x78(%rbp),%xmm1
movslq -0x24(%rbp),%rax
mulsd  -0xc0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x24(%rbp),%eax
add    $0x4,%eax
cltq
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13fa <IncompleteGamma+0x2da>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    148a <IncompleteGamma+0x36a>
jp     148a <IncompleteGamma+0x36a>
jmp    14fb <IncompleteGamma+0x3db>
movsd  -0xa0(%rbp),%xmm0
ff
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movaps 0xb80(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    14ce <IncompleteGamma+0x3ae>
jmp    14f1 <IncompleteGamma+0x3d1>
movsd  -0x80(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     14ec <IncompleteGamma+0x3cc>
jmp    15a2 <IncompleteGamma+0x482>
jmp    14f1 <IncompleteGamma+0x3d1>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    1538 <IncompleteGamma+0x418>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x24(%rbp),%rax
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1502 <IncompleteGamma+0x3e2>
movsd  -0xa0(%rbp),%xmm1
ff
movaps 0xae9(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    155f <IncompleteGamma+0x43f>
jmp    13a5 <IncompleteGamma+0x285>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    159d <IncompleteGamma+0x47d>
movsd  -0x48(%rbp),%xmm1
movslq -0x24(%rbp),%rax
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1566 <IncompleteGamma+0x446>
jmp    13a5 <IncompleteGamma+0x285>
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xa41(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<IncompleteGamma>:
sub    $0x68,%rsp
movapd %xmm0,%xmm4
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm4
jne    1139 <IncompleteGamma+0x19>
jp     1139 <IncompleteGamma+0x19>
add    $0x68,%rsp
ret
xorpd  %xmm3,%xmm3
ucomisd %xmm4,%xmm3
movsd  0xeb7(%rip),%xmm0
ja     1134 <IncompleteGamma+0x14>
ucomisd %xmm1,%xmm3
jae    1134 <IncompleteGamma+0x14>
movapd %xmm4,%xmm0
movapd %xmm4,0x50(%rsp)
movsd  %xmm1,0x8(%rsp)
movsd  %xmm2,0x48(%rsp)
call   1040 <log@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
mulsd  0x8(%rsp),%xmm0
subsd  0x50(%rsp),%xmm0
subsd  0x48(%rsp),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm8
movapd 0x50(%rsp),%xmm3
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
ucomisd 0xe60(%rip),%xmm3
jbe    1358 <IncompleteGamma+0x238>
ucomisd %xmm8,%xmm3
jb     1358 <IncompleteGamma+0x238>
movsd  0xe46(%rip),%xmm15
movapd %xmm15,%xmm2
subsd  %xmm8,%xmm2
movapd %xmm2,%xmm4
addsd  %xmm3,%xmm4
addsd  %xmm15,%xmm4
movabs $0x3ff0000000000000,%rax
mov    %rax,0x10(%rsp)
movsd  %xmm3,0x18(%rsp)
lea    0x20(%rsp),%rax
movapd %xmm15,%xmm1
unpcklpd %xmm3,%xmm1
unpcklpd %xmm3,%xmm3
movapd %xmm15,%xmm5
unpcklpd %xmm4,%xmm5
movapd %xmm3,%xmm7
addpd  %xmm5,%xmm7
mulpd  %xmm3,%xmm5
movapd %xmm5,%xmm3
movsd  %xmm7,%xmm3
movapd %xmm3,0x20(%rsp)
unpckhpd %xmm5,%xmm5
divsd  %xmm5,%xmm7
unpcklpd %xmm4,%xmm2
xorpd  %xmm8,%xmm8
movapd 0xde3(%rip),%xmm10
movapd 0xdea(%rip),%xmm11
movapd 0xdf1(%rip),%xmm14
movsd  0xdc0(%rip),%xmm12
movapd 0xdef(%rip),%xmm13
movsd  0xda6(%rip),%xmm9
xorpd  %xmm4,%xmm4
jmp    1296 <IncompleteGamma+0x176>
movapd 0x10(%rsp),%xmm1
movapd 0x20(%rsp),%xmm3
divpd  %xmm13,%xmm1
movapd %xmm1,0x10(%rsp)
divpd  %xmm13,%xmm3
movapd %xmm3,0x20(%rsp)
movapd %xmm6,%xmm7
addpd  %xmm10,%xmm2
addsd  %xmm15,%xmm4
movapd %xmm2,%xmm5
xorpd  %xmm11,%xmm5
mulsd  %xmm4,%xmm5
unpcklpd %xmm5,%xmm5
mulpd  %xmm1,%xmm5
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm5,%xmm1
movapd %xmm1,0x30(%rsp)
movapd %xmm1,%xmm3
unpckhpd %xmm1,%xmm3
ucomisd %xmm8,%xmm3
jne    12f0 <IncompleteGamma+0x1d0>
jp     12f0 <IncompleteGamma+0x1d0>
movapd %xmm7,%xmm6
jmp    1320 <IncompleteGamma+0x200>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm1,%xmm6
divsd  %xmm3,%xmm6
movapd %xmm7,%xmm3
subsd  %xmm6,%xmm3
andpd  %xmm14,%xmm3
ucomisd %xmm9,%xmm3
ja     1320 <IncompleteGamma+0x200>
movapd %xmm6,%xmm5
mulsd  %xmm9,%xmm5
ucomisd %xmm3,%xmm5
jae    13a8 <IncompleteGamma+0x288>
nop
movaps (%rax),%xmm3
movapd 0x10(%rax),%xmm5
movapd %xmm5,0x20(%rsp)
movaps %xmm3,0x10(%rsp)
andpd  %xmm14,%xmm1
ucomisd %xmm1,%xmm12
jbe    1270 <IncompleteGamma+0x150>
movapd 0x10(%rsp),%xmm1
movapd 0x20(%rsp),%xmm3
movapd %xmm6,%xmm7
jmp    1296 <IncompleteGamma+0x176>
movsd  0xca8(%rip),%xmm2
movsd  0xca8(%rip),%xmm7
movapd %xmm2,%xmm1
movapd %xmm8,%xmm4
movapd %xmm2,%xmm5
cs nopw 0x0(%rax,%rax,1)
nop
addsd  %xmm2,%xmm4
movapd %xmm3,%xmm6
divsd  %xmm4,%xmm6
mulsd  %xmm6,%xmm5
addsd  %xmm5,%xmm1
ucomisd %xmm7,%xmm5
ja     1380 <IncompleteGamma+0x260>
divsd  %xmm8,%xmm0
mulsd  %xmm1,%xmm0
add    $0x68,%rsp
ret
mulsd  %xmm7,%xmm0
subsd  %xmm0,%xmm15
movapd %xmm15,%xmm0
add    $0x68,%rsp
ret

LLVM IR (-O0):
define double @IncompleteGamma(double %0, double %1, double %2) {
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca i32
%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 [6 x double]
store double %0, double* %5
store double %1, double* %6
store double %2, double* %7
%22 = load double, double* %6
store double %22, double* %9
%23 = load double, double* %7
store double %23, double* %10
store double 1.000000e-08, double* %11
store double 1.000000e+30, double* %12
store double 0.000000e+00, double* %14
store double 0.000000e+00, double* %15
store double 0.000000e+00, double* %16
store double 0.000000e+00, double* %17
store double 0.000000e+00, double* %18
store double 0.000000e+00, double* %19
store double 0.000000e+00, double* %20
%24 = load double, double* %5
%25 = fcmp oeq double %24, 0.000000e+00
br i1 %25, label %26, label %27
26: ; preds = %3
store double 0.000000e+00, double* %4
br label %207
27: ; preds = %3
%28 = load double, double* %5
%29 = fcmp olt double %28, 0.000000e+00
br i1 %29, label %33, label %30
30: ; preds = %27
%31 = load double, double* %9
%32 = fcmp ole double %31, 0.000000e+00
br i1 %32, label %33, label %34
33: ; preds = %30, %27
store double -1.000000e+00, double* %4
br label %207
34: ; preds = %30
%35 = load double, double* %9
%36 = load double, double* %5
%37 = call i64 @log(double %36)
%38 = sitofp i64 %37 to double
%39 = load double, double* %5
%40 = fneg double %39
%41 = call double @llvm.fmuladd.f64(double %35, double %38, double %40)
%42 = load double, double* %10
%43 = fsub double %41, %42
%44 = call i64 @exp(double %43)
%45 = sitofp i64 %44 to double
store double %45, double* %13
%46 = load double, double* %5
%47 = fcmp ogt double %46, 1.000000e+00
br i1 %47, label %48, label %53
48: ; preds = %34
%49 = load double, double* %5
%50 = load double, double* %9
%51 = fcmp oge double %49, %50
br i1 %51, label %52, label %53
52: ; preds = %48
br label %76
53: ; preds = %48, %34
store double 1.000000e+00, double* %14
store double 1.000000e+00, double* %20
%54 = load double, double* %9
store double %54, double* %15
br label %55
55: ; preds = %69, %53
%56 = load double, double* %15
%57 = fadd double %56, 1.000000e+00
store double %57, double* %15
%58 = load double, double* %5
%59 = load double, double* %15
%60 = fdiv double %58, %59
%61 = load double, double* %20
%62 = fmul double %61, %60
store double %62, double* %20
%63 = load double, double* %20
%64 = load double, double* %14
%65 = fadd double %64, %63
store double %65, double* %14
%66 = load double, double* %20
%67 = load double, double* %11
%68 = fcmp ogt double %66, %67
br i1 %68, label %69, label %70
69: ; preds = %55
br label %55
70: ; preds = %55
%71 = load double, double* %13
%72 = load double, double* %9
%73 = fdiv double %71, %72
%74 = load double, double* %14
%75 = fmul double %74, %73
store double %75, double* %14
br label %205
76: ; preds = %52
%77 = load double, double* %9
%78 = fsub double 1.000000e+00, %77
store double %78, double* %16
%79 = load double, double* %16
%80 = load double, double* %5
%81 = fadd double %79, %80
%82 = fadd double %81, 1.000000e+00
store double %82, double* %17
store double 0.000000e+00, double* %20
%83 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 0
store double 1.000000e+00, double* %83
%84 = load double, double* %5
%85 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 1
store double %84, double* %85
%86 = load double, double* %5
%87 = fadd double %86, 1.000000e+00
%88 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 2
store double %87, double* %88
%89 = load double, double* %5
%90 = load double, double* %17
%91 = fmul double %89, %90
%92 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 3
store double %91, double* %92
%93 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 2
%94 = load double, double* %93
%95 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 3
%96 = load double, double* %95
%97 = fdiv double %94, %96
store double %97, double* %14
br label %98
98: ; preds = %199, %184, %76
%99 = load double, double* %16
%100 = fadd double %99, 1.000000e+00
store double %100, double* %16
%101 = load double, double* %17
%102 = fadd double %101, 2.000000e+00
store double %102, double* %17
%103 = load double, double* %20
%104 = fadd double %103, 1.000000e+00
store double %104, double* %20
%105 = load double, double* %16
%106 = load double, double* %20
%107 = fmul double %105, %106
store double %107, double* %18
store i32 0, i32* %8
br label %108
108: ; preds = %130, %98
%109 = load i32, i32* %8
%110 = icmp slt i32 %109, 2
br i1 %110, label %111, label %133
111: ; preds = %108
%112 = load double, double* %17
%113 = load i32, i32* %8
%114 = add nsw i32 %113, 2
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %115
%117 = load double, double* %116
%118 = load double, double* %18
%119 = load i32, i32* %8
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %120
%122 = load double, double* %121
%123 = fmul double %118, %122
%124 = fneg double %123
%125 = call double @llvm.fmuladd.f64(double %112, double %117, double %124)
%126 = load i32, i32* %8
%127 = add nsw i32 %126, 4
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %128
store double %125, double* %129
br label %130
130: ; preds = %111
%131 = load i32, i32* %8
%132 = add nsw i32 %131, 1
store i32 %132, i32* %8
br label %108
133: ; preds = %108
%134 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 5
%135 = load double, double* %134
%136 = fcmp oeq double %135, 0.000000e+00
br i1 %136, label %137, label %138
137: ; preds = %133
br label %162
138: ; preds = %133
%139 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 4
%140 = load double, double* %139
%141 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 5
%142 = load double, double* %141
%143 = fdiv double %140, %142
store double %143, double* %15
%144 = load double, double* %14
%145 = load double, double* %15
%146 = fsub double %144, %145
%147 = call double @llvm.fabs.f64(double %146)
store double %147, double* %19
%148 = load double, double* %19
%149 = load double, double* %11
%150 = fcmp ogt double %148, %149
br i1 %150, label %151, label %152
151: ; preds = %138
br label %160
152: ; preds = %138
%153 = load double, double* %19
%154 = load double, double* %11
%155 = load double, double* %15
%156 = fmul double %154, %155
%157 = fcmp ole double %153, %156
br i1 %157, label %158, label %159
158: ; preds = %152
br label %200
159: ; preds = %152
br label %160
160: ; preds = %159, %151
%161 = load double, double* %15
store double %161, double* %14
br label %162
162: ; preds = %160, %137
store i32 0, i32* %8
br label %163
163: ; preds = %175, %162
%164 = load i32, i32* %8
%165 = icmp slt i32 %164, 4
br i1 %165, label %166, label %178
166: ; preds = %163
%167 = load i32, i32* %8
%168 = add nsw i32 %167, 2
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %169
%171 = load double, double* %170
%172 = load i32, i32* %8
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %173
store double %171, double* %174
br label %175
175: ; preds = %166
%176 = load i32, i32* %8
%177 = add nsw i32 %176, 1
store i32 %177, i32* %8
br label %163
178: ; preds = %163
%179 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 4
%180 = load double, double* %179
%181 = call double @llvm.fabs.f64(double %180)
%182 = load double, double* %12
%183 = fcmp olt double %181, %182
br i1 %183, label %184, label %185
184: ; preds = %178
br label %98
185: ; preds = %178
store i32 0, i32* %8
br label %186
186: ; preds = %196, %185
%187 = load i32, i32* %8
%188 = icmp slt i32 %187, 4
br i1 %188, label %189, label %199
189: ; preds = %186
%190 = load double, double* %12
%191 = load i32, i32* %8
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %192
%194 = load double, double* %193
%195 = fdiv double %194, %190
store double %195, double* %193
br label %196
196: ; preds = %189
%197 = load i32, i32* %8
%198 = add nsw i32 %197, 1
store i32 %198, i32* %8
br label %186
199: ; preds = %186
br label %98
200: ; preds = %158
%201 = load double, double* %13
%202 = load double, double* %14
%203 = fneg double %201
%204 = call double @llvm.fmuladd.f64(double %203, double %202, double 1.000000e+00)
store double %204, double* %14
br label %205
205: ; preds = %200, %70
%206 = load double, double* %14
store double %206, double* %4
br label %207
207: ; preds = %205, %33, %26
%208 = load double, double* %4
ret double %208
}

LLVM IR (-O2):
define double @IncompleteGamma(double %0, double %1, double %2) {
%4 = alloca [6 x double]
%5 = bitcast [6 x double]* %4 to i8*
%6 = fcmp oeq double %0, 0.000000e+00
br i1 %6, label %109, label %7
7: ; preds = %3
%8 = fcmp olt double %0, 0.000000e+00
%9 = fcmp ole double %1, 0.000000e+00
%10 = or i1 %8, %9
br i1 %10, label %109, label %11
11: ; preds = %7
%12 = tail call i64 @log(double %0)
%13 = sitofp i64 %12 to double
%14 = fneg double %0
%15 = tail call double @llvm.fmuladd.f64(double %1, double %13, double %14)
%16 = fsub double %15, %2
%17 = tail call i64 @exp(double %16)
%18 = sitofp i64 %17 to double
%19 = fcmp ule double %0, 1.000000e+00
%20 = fcmp ult double %0, %1
%21 = or i1 %19, %20
br i1 %21, label %22, label %34
22: ; preds = %11, %22
%23 = phi double [ %29, %22 ], [ 1.000000e+00, %11 ]
%24 = phi double [ %26, %22 ], [ %1, %11 ]
%25 = phi double [ %28, %22 ], [ 1.000000e+00, %11 ]
%26 = fadd double %24, 1.000000e+00
%27 = fdiv double %0, %26
%28 = fmul double %25, %27
%29 = fadd double %23, %28
%30 = fcmp ogt double %28, 1.000000e-08
br i1 %30, label %22, label %31
31: ; preds = %22
%32 = fdiv double %18, %1
%33 = fmul double %32, %29
br label %109
34: ; preds = %11
%35 = fsub double 1.000000e+00, %1
%36 = fadd double %35, %0
%37 = fadd double %36, 1.000000e+00
%38 = getelementptr inbounds [6 x double], [6 x double]* %4, i64 0, i64 0
store double 1.000000e+00, double* %38
%39 = getelementptr inbounds [6 x double], [6 x double]* %4, i64 0, i64 1
store double %0, double* %39
%40 = getelementptr inbounds [6 x double], [6 x double]* %4, i64 0, i64 2
%41 = insertelement <2 x double> poison, double %0, i64 0
%42 = shufflevector <2 x double> %41, <2 x double> poison, <2 x i32> zeroinitializer
%43 = insertelement <2 x double> <double 1.000000e+00, double poison>, double %37, i64 1
%44 = fadd <2 x double> %42, %43
%45 = fmul <2 x double> %42, %43
%46 = shufflevector <2 x double> %44, <2 x double> %45, <2 x i32> <i32 0, i32 3>
%47 = bitcast double* %40 to <2 x double>*
store <2 x double> %46, <2 x double>* %47
%48 = extractelement <2 x double> %44, i64 0
%49 = extractelement <2 x double> %45, i64 1
%50 = fdiv double %48, %49
%51 = getelementptr inbounds [6 x double], [6 x double]* %4, i64 0, i64 4
%52 = bitcast double* %40 to i8*
%53 = insertelement <2 x double> <double 1.000000e+00, double poison>, double %0, i64 1
%54 = insertelement <2 x double> poison, double %35, i64 0
%55 = insertelement <2 x double> %54, double %37, i64 1
%56 = bitcast double* %51 to <2 x double>*
%57 = bitcast [6 x double]* %4 to <2 x double>*
%58 = bitcast [6 x double]* %4 to <2 x double>*
%59 = bitcast double* %40 to <2 x double>*
%60 = bitcast double* %40 to <2 x double>*
%61 = bitcast double* %40 to <2 x double>*
%62 = bitcast [6 x double]* %4 to <2 x double>*
br label %63
63: ; preds = %98, %34
%64 = phi double [ %50, %34 ], [ %91, %98 ]
%65 = phi double [ 0.000000e+00, %34 ], [ %70, %98 ]
%66 = phi <2 x double> [ %46, %34 ], [ %99, %98 ]
%67 = phi <2 x double> [ %53, %34 ], [ %100, %98 ]
%68 = phi <2 x double> [ %55, %34 ], [ %69, %98 ]
%69 = fadd <2 x double> %68, <double 1.000000e+00, double 2.000000e+00>
%70 = fadd double %65, 1.000000e+00
%71 = extractelement <2 x double> %69, i64 0
%72 = fneg double %71
%73 = fmul double %70, %72
%74 = insertelement <2 x double> poison, double %73, i64 0
%75 = shufflevector <2 x double> %74, <2 x double> poison, <2 x i32> zeroinitializer
%76 = fmul <2 x double> %75, %67
%77 = shufflevector <2 x double> %69, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%78 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %77, <2 x double> %66, <2 x double> %76)
store <2 x double> %78, <2 x double>* %56
%79 = extractelement <2 x double> %78, i64 1
%80 = fcmp oeq double %79, 0.000000e+00
br i1 %80, label %90, label %81
81: ; preds = %63
%82 = extractelement <2 x double> %78, i64 0
%83 = fdiv double %82, %79
%84 = fsub double %64, %83
%85 = tail call double @llvm.fabs.f64(double %84)
%86 = fcmp ogt double %85, 1.000000e-08
%87 = fmul double %83, 1.000000e-08
%88 = fcmp ugt double %85, %87
%89 = select i1 %86, i1 true, i1 %88
br i1 %89, label %90, label %106
90: ; preds = %81, %63
%91 = phi double [ %64, %63 ], [ %83, %81 ]
%92 = extractelement <2 x double> %78, i64 0
%93 = tail call double @llvm.fabs.f64(double %92)
%94 = fcmp olt double %93, 1.000000e+30
br i1 %94, label %95, label %101
95: ; preds = %90
%96 = load <2 x double>, <2 x double>* %61
%97 = load <2 x double>, <2 x double>* %62
br label %98
98: ; preds = %95, %101
%99 = phi <2 x double> [ %96, %95 ], [ %105, %101 ]
%100 = phi <2 x double> [ %97, %95 ], [ %103, %101 ]
br label %63
101: ; preds = %90
%102 = load <2 x double>, <2 x double>* %57
%103 = fdiv <2 x double> %102, <double 1.000000e+30, double 1.000000e+30>
store <2 x double> %103, <2 x double>* %58
%104 = load <2 x double>, <2 x double>* %59
%105 = fdiv <2 x double> %104, <double 1.000000e+30, double 1.000000e+30>
store <2 x double> %105, <2 x double>* %60
br label %98
106: ; preds = %81
%107 = fneg double %18
%108 = tail call double @llvm.fmuladd.f64(double %107, double %64, double 1.000000e+00)
br label %109
109: ; preds = %31, %106, %7, %3
%110 = phi double [ 0.000000e+00, %3 ], [ -1.000000e+00, %7 ], [ %108, %106 ], [ %33, %31 ]
ret double %110
}