#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(double);
double fabs(double);
double log(double);
double seq_gen_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 = exp(p * 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):
<seq_gen_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 <seq_gen_IncompleteGamma+0xa8>
jp     11c8 <seq_gen_IncompleteGamma+0xa8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    15db <seq_gen_IncompleteGamma+0x4bb>
xorps  %xmm0,%xmm0
ucomisd -0x10(%rbp),%xmm0
ja     11e4 <seq_gen_IncompleteGamma+0xc4>
xorps  %xmm0,%xmm0
ucomisd -0x30(%rbp),%xmm0
jb     11f6 <seq_gen_IncompleteGamma+0xd6>
movsd  0xe34(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    15db <seq_gen_IncompleteGamma+0x4bb>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm2
movsd  -0xc8(%rbp),%xmm0
ff
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>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  0xdb8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1277 <seq_gen_IncompleteGamma+0x157>
movsd  -0x10(%rbp),%xmm0
ucomisd -0x30(%rbp),%xmm0
jb     1277 <seq_gen_IncompleteGamma+0x157>
jmp    130d <seq_gen_IncompleteGamma+0x1ed>
movsd  0xd91(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xd84(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xd6a(%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    12f4 <seq_gen_IncompleteGamma+0x1d4>
jmp    129e <seq_gen_IncompleteGamma+0x17e>
movsd  -0x50(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    15d1 <seq_gen_IncompleteGamma+0x4b1>
movsd  0xcfb(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
addsd  -0x10(%rbp),%xmm0
movsd  0xcdf(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xcc3(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xca6(%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  0xc6a(%rip),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0xc60(%rip),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xc46(%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    1463 <seq_gen_IncompleteGamma+0x343>
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    13f3 <seq_gen_IncompleteGamma+0x2d3>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1483 <seq_gen_IncompleteGamma+0x363>
jp     1483 <seq_gen_IncompleteGamma+0x363>
jmp    14f4 <seq_gen_IncompleteGamma+0x3d4>
movsd  -0xa0(%rbp),%xmm0
ff
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movaps 0xb87(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    14c7 <seq_gen_IncompleteGamma+0x3a7>
jmp    14ea <seq_gen_IncompleteGamma+0x3ca>
movsd  -0x80(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     14e5 <seq_gen_IncompleteGamma+0x3c5>
jmp    159b <seq_gen_IncompleteGamma+0x47b>
jmp    14ea <seq_gen_IncompleteGamma+0x3ca>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    1531 <seq_gen_IncompleteGamma+0x411>
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    14fb <seq_gen_IncompleteGamma+0x3db>
movsd  -0xa0(%rbp),%xmm1
ff
movaps 0xaf0(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1558 <seq_gen_IncompleteGamma+0x438>
jmp    139e <seq_gen_IncompleteGamma+0x27e>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    1596 <seq_gen_IncompleteGamma+0x476>
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    155f <seq_gen_IncompleteGamma+0x43f>
jmp    139e <seq_gen_IncompleteGamma+0x27e>
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xa48(%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):
<seq_gen_IncompleteGamma>:
sub    $0x68,%rsp
movapd %xmm0,%xmm4
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm4
jne    1139 <seq_gen_IncompleteGamma+0x19>
jp     1139 <seq_gen_IncompleteGamma+0x19>
add    $0x68,%rsp
ret
xorpd  %xmm3,%xmm3
ucomisd %xmm4,%xmm3
movsd  0xeb7(%rip),%xmm0
ja     1134 <seq_gen_IncompleteGamma+0x14>
ucomisd %xmm1,%xmm3
jae    1134 <seq_gen_IncompleteGamma+0x14>
movapd %xmm4,%xmm0
movapd %xmm4,0x50(%rsp)
movsd  %xmm1,0x8(%rsp)
movsd  %xmm2,0x48(%rsp)
call   1040 <log@plt>
mulsd  0x8(%rsp),%xmm0
subsd  0x50(%rsp),%xmm0
subsd  0x48(%rsp),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm8
movapd 0x50(%rsp),%xmm3
ucomisd 0xe70(%rip),%xmm3
jbe    1348 <seq_gen_IncompleteGamma+0x228>
ucomisd %xmm8,%xmm3
jb     1348 <seq_gen_IncompleteGamma+0x228>
movsd  0xe56(%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 0xdf3(%rip),%xmm10
movapd 0xdfa(%rip),%xmm11
movapd 0xe01(%rip),%xmm14
movsd  0xdd0(%rip),%xmm12
movapd 0xdff(%rip),%xmm13
movsd  0xdb6(%rip),%xmm9
xorpd  %xmm4,%xmm4
jmp    1286 <seq_gen_IncompleteGamma+0x166>
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    12e0 <seq_gen_IncompleteGamma+0x1c0>
jp     12e0 <seq_gen_IncompleteGamma+0x1c0>
movapd %xmm7,%xmm6
jmp    1310 <seq_gen_IncompleteGamma+0x1f0>
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     1310 <seq_gen_IncompleteGamma+0x1f0>
movapd %xmm6,%xmm5
mulsd  %xmm9,%xmm5
ucomisd %xmm3,%xmm5
jae    1398 <seq_gen_IncompleteGamma+0x278>
nop
movaps (%rax),%xmm3
movapd 0x10(%rax),%xmm5
movapd %xmm5,0x20(%rsp)
movaps %xmm3,0x10(%rsp)
andpd  %xmm14,%xmm1
ucomisd %xmm1,%xmm12
jbe    1260 <seq_gen_IncompleteGamma+0x140>
movapd 0x10(%rsp),%xmm1
movapd 0x20(%rsp),%xmm3
movapd %xmm6,%xmm7
jmp    1286 <seq_gen_IncompleteGamma+0x166>
movsd  0xcb8(%rip),%xmm2
movsd  0xcb8(%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     1370 <seq_gen_IncompleteGamma+0x250>
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 @seq_gen_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 %205
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 %205
34: ; preds = %30
%35 = load double, double* %9
%36 = load double, double* %5
%37 = call double @log(double %36)
%38 = load double, double* %5
%39 = fneg double %38
%40 = call double @llvm.fmuladd.f64(double %35, double %37, double %39)
%41 = load double, double* %10
%42 = fsub double %40, %41
%43 = call double @exp(double %42)
store double %43, double* %13
%44 = load double, double* %5
%45 = fcmp ogt double %44, 1.000000e+00
br i1 %45, label %46, label %51
46: ; preds = %34
%47 = load double, double* %5
%48 = load double, double* %9
%49 = fcmp oge double %47, %48
br i1 %49, label %50, label %51
50: ; preds = %46
br label %74
51: ; preds = %46, %34
store double 1.000000e+00, double* %14
store double 1.000000e+00, double* %20
%52 = load double, double* %9
store double %52, double* %15
br label %53
53: ; preds = %67, %51
%54 = load double, double* %15
%55 = fadd double %54, 1.000000e+00
store double %55, double* %15
%56 = load double, double* %5
%57 = load double, double* %15
%58 = fdiv double %56, %57
%59 = load double, double* %20
%60 = fmul double %59, %58
store double %60, double* %20
%61 = load double, double* %20
%62 = load double, double* %14
%63 = fadd double %62, %61
store double %63, double* %14
%64 = load double, double* %20
%65 = load double, double* %11
%66 = fcmp ogt double %64, %65
br i1 %66, label %67, label %68
67: ; preds = %53
br label %53
68: ; preds = %53
%69 = load double, double* %13
%70 = load double, double* %9
%71 = fdiv double %69, %70
%72 = load double, double* %14
%73 = fmul double %72, %71
store double %73, double* %14
br label %203
74: ; preds = %50
%75 = load double, double* %9
%76 = fsub double 1.000000e+00, %75
store double %76, double* %16
%77 = load double, double* %16
%78 = load double, double* %5
%79 = fadd double %77, %78
%80 = fadd double %79, 1.000000e+00
store double %80, double* %17
store double 0.000000e+00, double* %20
%81 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 0
store double 1.000000e+00, double* %81
%82 = load double, double* %5
%83 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 1
store double %82, double* %83
%84 = load double, double* %5
%85 = fadd double %84, 1.000000e+00
%86 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 2
store double %85, double* %86
%87 = load double, double* %5
%88 = load double, double* %17
%89 = fmul double %87, %88
%90 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 3
store double %89, double* %90
%91 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 2
%92 = load double, double* %91
%93 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 3
%94 = load double, double* %93
%95 = fdiv double %92, %94
store double %95, double* %14
br label %96
96: ; preds = %197, %182, %74
%97 = load double, double* %16
%98 = fadd double %97, 1.000000e+00
store double %98, double* %16
%99 = load double, double* %17
%100 = fadd double %99, 2.000000e+00
store double %100, double* %17
%101 = load double, double* %20
%102 = fadd double %101, 1.000000e+00
store double %102, double* %20
%103 = load double, double* %16
%104 = load double, double* %20
%105 = fmul double %103, %104
store double %105, double* %18
store i32 0, i32* %8
br label %106
106: ; preds = %128, %96
%107 = load i32, i32* %8
%108 = icmp slt i32 %107, 2
br i1 %108, label %109, label %131
109: ; preds = %106
%110 = load double, double* %17
%111 = load i32, i32* %8
%112 = add nsw i32 %111, 2
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %113
%115 = load double, double* %114
%116 = load double, double* %18
%117 = load i32, i32* %8
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %118
%120 = load double, double* %119
%121 = fmul double %116, %120
%122 = fneg double %121
%123 = call double @llvm.fmuladd.f64(double %110, double %115, double %122)
%124 = load i32, i32* %8
%125 = add nsw i32 %124, 4
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %126
store double %123, double* %127
br label %128
128: ; preds = %109
%129 = load i32, i32* %8
%130 = add nsw i32 %129, 1
store i32 %130, i32* %8
br label %106
131: ; preds = %106
%132 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 5
%133 = load double, double* %132
%134 = fcmp oeq double %133, 0.000000e+00
br i1 %134, label %135, label %136
135: ; preds = %131
br label %160
136: ; preds = %131
%137 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 4
%138 = load double, double* %137
%139 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 5
%140 = load double, double* %139
%141 = fdiv double %138, %140
store double %141, double* %15
%142 = load double, double* %14
%143 = load double, double* %15
%144 = fsub double %142, %143
%145 = call double @llvm.fabs.f64(double %144)
store double %145, double* %19
%146 = load double, double* %19
%147 = load double, double* %11
%148 = fcmp ogt double %146, %147
br i1 %148, label %149, label %150
149: ; preds = %136
br label %158
150: ; preds = %136
%151 = load double, double* %19
%152 = load double, double* %11
%153 = load double, double* %15
%154 = fmul double %152, %153
%155 = fcmp ole double %151, %154
br i1 %155, label %156, label %157
156: ; preds = %150
br label %198
157: ; preds = %150
br label %158
158: ; preds = %157, %149
%159 = load double, double* %15
store double %159, double* %14
br label %160
160: ; preds = %158, %135
store i32 0, i32* %8
br label %161
161: ; preds = %173, %160
%162 = load i32, i32* %8
%163 = icmp slt i32 %162, 4
br i1 %163, label %164, label %176
164: ; preds = %161
%165 = load i32, i32* %8
%166 = add nsw i32 %165, 2
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %167
%169 = load double, double* %168
%170 = load i32, i32* %8
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %171
store double %169, double* %172
br label %173
173: ; preds = %164
%174 = load i32, i32* %8
%175 = add nsw i32 %174, 1
store i32 %175, i32* %8
br label %161
176: ; preds = %161
%177 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 4
%178 = load double, double* %177
%179 = call double @llvm.fabs.f64(double %178)
%180 = load double, double* %12
%181 = fcmp olt double %179, %180
br i1 %181, label %182, label %183
182: ; preds = %176
br label %96
183: ; preds = %176
store i32 0, i32* %8
br label %184
184: ; preds = %194, %183
%185 = load i32, i32* %8
%186 = icmp slt i32 %185, 4
br i1 %186, label %187, label %197
187: ; preds = %184
%188 = load double, double* %12
%189 = load i32, i32* %8
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds [6 x double], [6 x double]* %21, i64 0, i64 %190
%192 = load double, double* %191
%193 = fdiv double %192, %188
store double %193, double* %191
br label %194
194: ; preds = %187
%195 = load i32, i32* %8
%196 = add nsw i32 %195, 1
store i32 %196, i32* %8
br label %184
197: ; preds = %184
br label %96
198: ; preds = %156
%199 = load double, double* %13
%200 = load double, double* %14
%201 = fneg double %199
%202 = call double @llvm.fmuladd.f64(double %201, double %200, double 1.000000e+00)
store double %202, double* %14
br label %203
203: ; preds = %198, %68
%204 = load double, double* %14
store double %204, double* %4
br label %205
205: ; preds = %203, %33, %26
%206 = load double, double* %4
ret double %206
}

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