#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 const DBL_EPSILON;
int /*<<< orphan*/ assert(int);
double const pow1pm1(double const, double);
double pFDR_storey02(const double *pval, const unsigned int m,
                     const double lambda, const double gamma) {
  assert(NULL != pval);
  assert(lambda >= 0. && lambda <= 1.);
  assert(gamma >= 0. && gamma <= 1.);
  unsigned int w = 0;
  for (unsigned int i = 0; i < m; i++) {
    if (pval[i] > lambda)
      w++;
  }
  unsigned int r = 0;
  for (unsigned int i = 0; i < m; i++) {
    if (pval[i] - gamma <= gamma * DBL_EPSILON)
      r++;
  }
  const double pi_0 = (double)w / ((1. - lambda) * (double)m);
  const double PrReject = ((r > 0) ? (double)r : 1.) / (double)m;
  return pi_0 * gamma / (PrReject * -pow1pm1(-gamma, (double)m));
}


x86 assembly (clang, -O0):
<pFDR_storey02>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
xor    %eax,%eax
cmp    -0x8(%rbp),%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movsd  -0x18(%rbp),%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x41(%rbp)
jb     1176 <pFDR_storey02+0x56>
movsd  0xe95(%rip),%xmm0
ucomisd -0x18(%rbp),%xmm0
setae  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movsd  -0x20(%rbp),%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x42(%rbp)
jb     11ad <pFDR_storey02+0x8d>
movsd  0xe5e(%rip),%xmm0
ucomisd -0x20(%rbp),%xmm0
setae  %al
mov    %al,-0x42(%rbp)
mov    -0x42(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1207 <pFDR_storey02+0xe7>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x18(%rbp),%xmm0
jbe    11f4 <pFDR_storey02+0xd4>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11f9 <pFDR_storey02+0xd9>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11c8 <pFDR_storey02+0xa8>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1268 <pFDR_storey02+0x148>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x20(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    0x2daa(%rip),%rax
mulsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1255 <pFDR_storey02+0x135>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    125a <pFDR_storey02+0x13a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1215 <pFDR_storey02+0xf5>
mov    -0x24(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  0xd83(%rip),%xmm1
subsd  %xmm2,%xmm1
mov    -0xc(%rbp),%eax
cvtsi2sd %rax,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jbe    12b2 <pFDR_storey02+0x192>
mov    -0x2c(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    12c4 <pFDR_storey02+0x1a4>
movsd  0xd46(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    12c4 <pFDR_storey02+0x1a4>
movsd  -0x50(%rbp),%xmm0
mov    -0xc(%rbp),%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm1
movsd  %xmm1,-0x60(%rbp)
movaps 0xd12(%rip),%xmm1
pxor   %xmm1,%xmm0
mov    -0xc(%rbp),%eax
cvtsi2sd %rax,%xmm1
call   1040 <pow1pm1@plt>
movsd  -0x60(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x58(%rbp),%xmm0
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pFDR_storey02>:
push   %rbp
push   %rbx
sub    $0x38,%rsp
movapd %xmm1,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
mov    %esi,%ebp
mov    %rdi,%rbx
xor    %edi,%edi
test   %rbx,%rbx
setne  %dil
call   1030 <assert@plt>
xorpd  %xmm1,%xmm1
movapd 0x20(%rsp),%xmm0
ucomisd %xmm1,%xmm0
setae  %al
movsd  0xea3(%rip),%xmm1
ucomisd %xmm0,%xmm1
setae  %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
movapd 0x10(%rsp),%xmm0
ucomisd 0xe82(%rip),%xmm0
setae  %al
movsd  0xe6f(%rip),%xmm1
ucomisd %xmm0,%xmm1
setae  %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    %ebp,%eax
test   %ebp,%ebp
je     1315 <pFDR_storey02+0x1f5>
cmp    $0x4,%ebp
jae    11c7 <pFDR_storey02+0xa7>
xor    %ecx,%ecx
xor    %edx,%edx
movapd 0x10(%rsp),%xmm0
movapd 0x20(%rsp),%xmm10
jmp    12d0 <pFDR_storey02+0x1b0>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd 0x20(%rsp),%xmm10
movapd %xmm10,%xmm8
unpcklpd %xmm10,%xmm8
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
movapd 0x10(%rsp),%xmm0
je     14e0 <pFDR_storey02+0x3c0>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xorpd  %xmm1,%xmm1
xor    %esi,%esi
pxor   %xmm2,%xmm2
nopl   0x0(%rax)
movupd (%rbx,%rsi,8),%xmm3
movupd 0x10(%rbx,%rsi,8),%xmm4
movupd 0x20(%rbx,%rsi,8),%xmm5
movupd 0x30(%rbx,%rsi,8),%xmm6
movapd %xmm8,%xmm7
cmpltpd %xmm3,%xmm7
shufps $0xe8,%xmm7,%xmm7
psubd  %xmm7,%xmm1
movapd %xmm8,%xmm3
cmpltpd %xmm4,%xmm3
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm2
movapd %xmm8,%xmm3
cmpltpd %xmm5,%xmm3
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm1
movapd %xmm8,%xmm3
cmpltpd %xmm6,%xmm3
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm2
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1210 <pFDR_storey02+0xf0>
test   $0x1,%dl
je     12ab <pFDR_storey02+0x18b>
movupd (%rbx,%rsi,8),%xmm3
movupd 0x10(%rbx,%rsi,8),%xmm4
movapd %xmm8,%xmm5
cmpltpd %xmm3,%xmm5
shufps $0xe8,%xmm5,%xmm5
psubd  %xmm5,%xmm1
cmpltpd %xmm4,%xmm8
shufps $0xe8,%xmm8,%xmm8
psubd  %xmm8,%xmm2
paddd  %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm2
paddd  %xmm1,%xmm2
movd   %xmm2,%edx
cmp    %rax,%rcx
je     12eb <pFDR_storey02+0x1cb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm1
xor    %esi,%esi
ucomisd %xmm10,%xmm1
seta   %sil
add    %esi,%edx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12d0 <pFDR_storey02+0x1b0>
mov    %edx,%ecx
cvtsi2sd %rcx,%xmm11
test   %ebp,%ebp
je     130e <pFDR_storey02+0x1ee>
xorpd  %xmm8,%xmm8
mulsd  %xmm0,%xmm8
cmp    $0x4,%ebp
jae    134e <pFDR_storey02+0x22e>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1450 <pFDR_storey02+0x330>
movsd  %xmm11,0x8(%rsp)
movsd  0xce3(%rip),%xmm0
subsd  0x20(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %rax,%xmm1
mulsd  %xmm1,%xmm0
movsd  0x8(%rsp),%xmm11
divsd  %xmm0,%xmm11
movapd 0x10(%rsp),%xmm0
movsd  0xcb7(%rip),%xmm3
jmp    149a <pFDR_storey02+0x37a>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm8,%xmm9
unpcklpd %xmm8,%xmm9
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     14f8 <pFDR_storey02+0x3d8>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm1,%xmm1
xor    %esi,%esi
xorpd  %xmm4,%xmm4
xchg   %ax,%ax
movupd (%rbx,%rsi,8),%xmm5
movupd 0x10(%rbx,%rsi,8),%xmm6
movupd 0x20(%rbx,%rsi,8),%xmm7
movupd 0x30(%rbx,%rsi,8),%xmm2
subpd  %xmm3,%xmm5
subpd  %xmm3,%xmm6
cmplepd %xmm9,%xmm5
shufps $0xe8,%xmm5,%xmm5
psubd  %xmm5,%xmm1
cmplepd %xmm9,%xmm6
shufps $0xe8,%xmm6,%xmm6
psubd  %xmm6,%xmm4
subpd  %xmm3,%xmm7
subpd  %xmm3,%xmm2
cmplepd %xmm9,%xmm7
shufps $0xe8,%xmm7,%xmm7
psubd  %xmm7,%xmm1
cmplepd %xmm9,%xmm2
shufps $0xe8,%xmm2,%xmm2
psubd  %xmm2,%xmm4
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1390 <pFDR_storey02+0x270>
test   $0x1,%dl
je     142d <pFDR_storey02+0x30d>
movupd (%rbx,%rsi,8),%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm5
subpd  %xmm3,%xmm2
subpd  %xmm3,%xmm5
cmplepd %xmm9,%xmm2
shufps $0xe8,%xmm2,%xmm2
psubd  %xmm2,%xmm1
cmplepd %xmm9,%xmm5
shufps $0xe8,%xmm5,%xmm5
psubd  %xmm5,%xmm4
paddd  %xmm4,%xmm1
pshufd $0x55,%xmm1,%xmm2
paddd  %xmm1,%xmm2
movd   %xmm2,%edx
cmp    %rax,%rcx
je     146a <pFDR_storey02+0x34a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
ucomisd %xmm1,%xmm8
sbb    $0xffffffff,%edx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1450 <pFDR_storey02+0x330>
movsd  0xb8e(%rip),%xmm3
movapd %xmm3,%xmm2
xorps  %xmm1,%xmm1
cvtsi2sd %rax,%xmm1
subsd  %xmm10,%xmm2
mulsd  %xmm1,%xmm2
divsd  %xmm2,%xmm11
test   %edx,%edx
je     149a <pFDR_storey02+0x37a>
mov    %edx,%eax
xorps  %xmm3,%xmm3
cvtsi2sd %rax,%xmm3
divsd  %xmm1,%xmm3
movsd  %xmm3,0x10(%rsp)
mulsd  %xmm0,%xmm11
movsd  %xmm11,0x8(%rsp)
xorpd  0xb58(%rip),%xmm0
call   1040 <pow1pm1@plt>
xorpd  0xb4b(%rip),%xmm0
mulsd  0x10(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
add    $0x38,%rsp
pop    %rbx
pop    %rbp
ret
xorpd  %xmm1,%xmm1
xor    %esi,%esi
pxor   %xmm2,%xmm2
test   $0x1,%dl
jne    127e <pFDR_storey02+0x15e>
jmp    12ab <pFDR_storey02+0x18b>
pxor   %xmm1,%xmm1
xor    %esi,%esi
xorpd  %xmm4,%xmm4
test   $0x1,%dl
jne    13fe <pFDR_storey02+0x2de>
jmp    142d <pFDR_storey02+0x30d>

LLVM IR (-O0):
@DBL_EPSILON = constant double 0.000000e+00
define double @pFDR_storey02(double* %0, i32 %1, double %2, double %3) {
%5 = alloca double*
%6 = alloca i32
%7 = alloca double
%8 = alloca double
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca double
%14 = alloca double
store double* %0, double** %5
store i32 %1, i32* %6
store double %2, double* %7
store double %3, double* %8
%15 = load double*, double** %5
%16 = icmp ne double* null, %15
%17 = zext i1 %16 to i32
%18 = call i32 @assert(i32 %17)
%19 = load double, double* %7
%20 = fcmp oge double %19, 0.000000e+00
br i1 %20, label %21, label %24
21: ; preds = %4
%22 = load double, double* %7
%23 = fcmp ole double %22, 1.000000e+00
br label %24
24: ; preds = %21, %4
%25 = phi i1 [ false, %4 ], [ %23, %21 ]
%26 = zext i1 %25 to i32
%27 = call i32 @assert(i32 %26)
%28 = load double, double* %8
%29 = fcmp oge double %28, 0.000000e+00
br i1 %29, label %30, label %33
30: ; preds = %24
%31 = load double, double* %8
%32 = fcmp ole double %31, 1.000000e+00
br label %33
33: ; preds = %30, %24
%34 = phi i1 [ false, %24 ], [ %32, %30 ]
%35 = zext i1 %34 to i32
%36 = call i32 @assert(i32 %35)
store i32 0, i32* %9
store i32 0, i32* %10
br label %37
37: ; preds = %53, %33
%38 = load i32, i32* %10
%39 = load i32, i32* %6
%40 = icmp ult i32 %38, %39
br i1 %40, label %41, label %56
41: ; preds = %37
%42 = load double*, double** %5
%43 = load i32, i32* %10
%44 = zext i32 %43 to i64
%45 = getelementptr inbounds double, double* %42, i64 %44
%46 = load double, double* %45
%47 = load double, double* %7
%48 = fcmp ogt double %46, %47
br i1 %48, label %49, label %52
49: ; preds = %41
%50 = load i32, i32* %9
%51 = add i32 %50, 1
store i32 %51, i32* %9
br label %52
52: ; preds = %49, %41
br label %53
53: ; preds = %52
%54 = load i32, i32* %10
%55 = add i32 %54, 1
store i32 %55, i32* %10
br label %37
56: ; preds = %37
store i32 0, i32* %11
store i32 0, i32* %12
br label %57
57: ; preds = %77, %56
%58 = load i32, i32* %12
%59 = load i32, i32* %6
%60 = icmp ult i32 %58, %59
br i1 %60, label %61, label %80
61: ; preds = %57
%62 = load double*, double** %5
%63 = load i32, i32* %12
%64 = zext i32 %63 to i64
%65 = getelementptr inbounds double, double* %62, i64 %64
%66 = load double, double* %65
%67 = load double, double* %8
%68 = fsub double %66, %67
%69 = load double, double* %8
%70 = load double, double* @DBL_EPSILON
%71 = fmul double %69, %70
%72 = fcmp ole double %68, %71
br i1 %72, label %73, label %76
73: ; preds = %61
%74 = load i32, i32* %11
%75 = add i32 %74, 1
store i32 %75, i32* %11
br label %76
76: ; preds = %73, %61
br label %77
77: ; preds = %76
%78 = load i32, i32* %12
%79 = add i32 %78, 1
store i32 %79, i32* %12
br label %57
80: ; preds = %57
%81 = load i32, i32* %9
%82 = uitofp i32 %81 to double
%83 = load double, double* %7
%84 = fsub double 1.000000e+00, %83
%85 = load i32, i32* %6
%86 = uitofp i32 %85 to double
%87 = fmul double %84, %86
%88 = fdiv double %82, %87
store double %88, double* %13
%89 = load i32, i32* %11
%90 = icmp ugt i32 %89, 0
br i1 %90, label %91, label %94
91: ; preds = %80
%92 = load i32, i32* %11
%93 = uitofp i32 %92 to double
br label %95
94: ; preds = %80
br label %95
95: ; preds = %94, %91
%96 = phi double [ %93, %91 ], [ 1.000000e+00, %94 ]
%97 = load i32, i32* %6
%98 = uitofp i32 %97 to double
%99 = fdiv double %96, %98
store double %99, double* %14
%100 = load double, double* %13
%101 = load double, double* %8
%102 = fmul double %100, %101
%103 = load double, double* %14
%104 = load double, double* %8
%105 = fneg double %104
%106 = load i32, i32* %6
%107 = uitofp i32 %106 to double
%108 = call double @pow1pm1(double %105, double %107)
%109 = fneg double %108
%110 = fmul double %103, %109
%111 = fdiv double %102, %110
ret double %111
}

LLVM IR (-O2):
@DBL_EPSILON = constant double 0.000000e+00
define double @pFDR_storey02(double* %0, i32 %1, double %2, double %3) {
%5 = icmp ne double* %0, null
%6 = zext i1 %5 to i32
%7 = tail call i32 @assert(i32 %6)
%8 = fcmp oge double %2, 0.000000e+00
%9 = fcmp ole double %2, 1.000000e+00
%10 = and i1 %8, %9
%11 = zext i1 %10 to i32
%12 = tail call i32 @assert(i32 %11)
%13 = fcmp oge double %3, 0.000000e+00
%14 = fcmp ole double %3, 1.000000e+00
%15 = and i1 %13, %14
%16 = zext i1 %15 to i32
%17 = tail call i32 @assert(i32 %16)
%18 = icmp eq i32 %1, 0
br i1 %18, label %199, label %19
19: ; preds = %4
%20 = zext i32 %1 to i64
%21 = icmp ult i32 %1, 4
br i1 %21, label %94, label %22
22: ; preds = %19
%23 = and i64 %20, 4294967292
%24 = insertelement <2 x double> poison, double %2, i64 0
%25 = shufflevector <2 x double> %24, <2 x double> poison, <2 x i32> zeroinitializer
%26 = insertelement <2 x double> poison, double %2, i64 0
%27 = shufflevector <2 x double> %26, <2 x double> poison, <2 x i32> zeroinitializer
%28 = add nsw i64 %23, -4
%29 = lshr exact i64 %28, 2
%30 = add nuw nsw i64 %29, 1
%31 = and i64 %30, 1
%32 = icmp eq i64 %28, 0
br i1 %32, label %68, label %33
33: ; preds = %22
%34 = and i64 %30, 9223372036854775806
br label %35
35: ; preds = %35, %33
%36 = phi i64 [ 0, %33 ], [ %65, %35 ]
%37 = phi <2 x i32> [ zeroinitializer, %33 ], [ %63, %35 ]
%38 = phi <2 x i32> [ zeroinitializer, %33 ], [ %64, %35 ]
%39 = phi i64 [ 0, %33 ], [ %66, %35 ]
%40 = getelementptr inbounds double, double* %0, i64 %36
%41 = bitcast double* %40 to <2 x double>*
%42 = load <2 x double>, <2 x double>* %41
%43 = getelementptr inbounds double, double* %40, i64 2
%44 = bitcast double* %43 to <2 x double>*
%45 = load <2 x double>, <2 x double>* %44
%46 = fcmp ogt <2 x double> %42, %25
%47 = fcmp ogt <2 x double> %45, %27
%48 = zext <2 x i1> %46 to <2 x i32>
%49 = zext <2 x i1> %47 to <2 x i32>
%50 = add <2 x i32> %37, %48
%51 = add <2 x i32> %38, %49
%52 = or i64 %36, 4
%53 = getelementptr inbounds double, double* %0, i64 %52
%54 = bitcast double* %53 to <2 x double>*
%55 = load <2 x double>, <2 x double>* %54
%56 = getelementptr inbounds double, double* %53, i64 2
%57 = bitcast double* %56 to <2 x double>*
%58 = load <2 x double>, <2 x double>* %57
%59 = fcmp ogt <2 x double> %55, %25
%60 = fcmp ogt <2 x double> %58, %27
%61 = zext <2 x i1> %59 to <2 x i32>
%62 = zext <2 x i1> %60 to <2 x i32>
%63 = add <2 x i32> %50, %61
%64 = add <2 x i32> %51, %62
%65 = add nuw i64 %36, 8
%66 = add i64 %39, 2
%67 = icmp eq i64 %66, %34
br i1 %67, label %68, label %35
68: ; preds = %35, %22
%69 = phi <2 x i32> [ undef, %22 ], [ %63, %35 ]
%70 = phi <2 x i32> [ undef, %22 ], [ %64, %35 ]
%71 = phi i64 [ 0, %22 ], [ %65, %35 ]
%72 = phi <2 x i32> [ zeroinitializer, %22 ], [ %63, %35 ]
%73 = phi <2 x i32> [ zeroinitializer, %22 ], [ %64, %35 ]
%74 = icmp eq i64 %31, 0
br i1 %74, label %88, label %75
75: ; preds = %68
%76 = getelementptr inbounds double, double* %0, i64 %71
%77 = bitcast double* %76 to <2 x double>*
%78 = load <2 x double>, <2 x double>* %77
%79 = getelementptr inbounds double, double* %76, i64 2
%80 = bitcast double* %79 to <2 x double>*
%81 = load <2 x double>, <2 x double>* %80
%82 = fcmp ogt <2 x double> %78, %25
%83 = fcmp ogt <2 x double> %81, %27
%84 = zext <2 x i1> %82 to <2 x i32>
%85 = zext <2 x i1> %83 to <2 x i32>
%86 = add <2 x i32> %72, %84
%87 = add <2 x i32> %73, %85
br label %88
88: ; preds = %68, %75
%89 = phi <2 x i32> [ %69, %68 ], [ %86, %75 ]
%90 = phi <2 x i32> [ %70, %68 ], [ %87, %75 ]
%91 = add <2 x i32> %90, %89
%92 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %91)
%93 = icmp eq i64 %23, %20
br i1 %93, label %97, label %94
94: ; preds = %19, %88
%95 = phi i64 [ 0, %19 ], [ %23, %88 ]
%96 = phi i32 [ 0, %19 ], [ %92, %88 ]
br label %189
97: ; preds = %189, %88
%98 = phi i32 [ %92, %88 ], [ %196, %189 ]
%99 = uitofp i32 %98 to double
br i1 %18, label %199, label %100
100: ; preds = %97
%101 = fmul double %3, 0.000000e+00
%102 = zext i32 %1 to i64
%103 = icmp ult i32 %1, 4
br i1 %103, label %186, label %104
104: ; preds = %100
%105 = and i64 %20, 4294967292
%106 = insertelement <2 x double> poison, double %3, i64 0
%107 = shufflevector <2 x double> %106, <2 x double> poison, <2 x i32> zeroinitializer
%108 = insertelement <2 x double> poison, double %3, i64 0
%109 = shufflevector <2 x double> %108, <2 x double> poison, <2 x i32> zeroinitializer
%110 = insertelement <2 x double> poison, double %101, i64 0
%111 = shufflevector <2 x double> %110, <2 x double> poison, <2 x i32> zeroinitializer
%112 = insertelement <2 x double> poison, double %101, i64 0
%113 = shufflevector <2 x double> %112, <2 x double> poison, <2 x i32> zeroinitializer
%114 = add nsw i64 %105, -4
%115 = lshr exact i64 %114, 2
%116 = add nuw nsw i64 %115, 1
%117 = and i64 %116, 1
%118 = icmp eq i64 %114, 0
br i1 %118, label %158, label %119
119: ; preds = %104
%120 = and i64 %116, 9223372036854775806
br label %121
121: ; preds = %121, %119
%122 = phi i64 [ 0, %119 ], [ %155, %121 ]
%123 = phi <2 x i32> [ zeroinitializer, %119 ], [ %153, %121 ]
%124 = phi <2 x i32> [ zeroinitializer, %119 ], [ %154, %121 ]
%125 = phi i64 [ 0, %119 ], [ %156, %121 ]
%126 = getelementptr inbounds double, double* %0, i64 %122
%127 = bitcast double* %126 to <2 x double>*
%128 = load <2 x double>, <2 x double>* %127
%129 = getelementptr inbounds double, double* %126, i64 2
%130 = bitcast double* %129 to <2 x double>*
%131 = load <2 x double>, <2 x double>* %130
%132 = fsub <2 x double> %128, %107
%133 = fsub <2 x double> %131, %109
%134 = fcmp ole <2 x double> %132, %111
%135 = fcmp ole <2 x double> %133, %113
%136 = zext <2 x i1> %134 to <2 x i32>
%137 = zext <2 x i1> %135 to <2 x i32>
%138 = add <2 x i32> %123, %136
%139 = add <2 x i32> %124, %137
%140 = or i64 %122, 4
%141 = getelementptr inbounds double, double* %0, i64 %140
%142 = bitcast double* %141 to <2 x double>*
%143 = load <2 x double>, <2 x double>* %142
%144 = getelementptr inbounds double, double* %141, i64 2
%145 = bitcast double* %144 to <2 x double>*
%146 = load <2 x double>, <2 x double>* %145
%147 = fsub <2 x double> %143, %107
%148 = fsub <2 x double> %146, %109
%149 = fcmp ole <2 x double> %147, %111
%150 = fcmp ole <2 x double> %148, %113
%151 = zext <2 x i1> %149 to <2 x i32>
%152 = zext <2 x i1> %150 to <2 x i32>
%153 = add <2 x i32> %138, %151
%154 = add <2 x i32> %139, %152
%155 = add nuw i64 %122, 8
%156 = add i64 %125, 2
%157 = icmp eq i64 %156, %120
br i1 %157, label %158, label %121
158: ; preds = %121, %104
%159 = phi <2 x i32> [ undef, %104 ], [ %153, %121 ]
%160 = phi <2 x i32> [ undef, %104 ], [ %154, %121 ]
%161 = phi i64 [ 0, %104 ], [ %155, %121 ]
%162 = phi <2 x i32> [ zeroinitializer, %104 ], [ %153, %121 ]
%163 = phi <2 x i32> [ zeroinitializer, %104 ], [ %154, %121 ]
%164 = icmp eq i64 %117, 0
br i1 %164, label %180, label %165
165: ; preds = %158
%166 = getelementptr inbounds double, double* %0, i64 %161
%167 = bitcast double* %166 to <2 x double>*
%168 = load <2 x double>, <2 x double>* %167
%169 = getelementptr inbounds double, double* %166, i64 2
%170 = bitcast double* %169 to <2 x double>*
%171 = load <2 x double>, <2 x double>* %170
%172 = fsub <2 x double> %168, %107
%173 = fsub <2 x double> %171, %109
%174 = fcmp ole <2 x double> %172, %111
%175 = fcmp ole <2 x double> %173, %113
%176 = zext <2 x i1> %174 to <2 x i32>
%177 = zext <2 x i1> %175 to <2 x i32>
%178 = add <2 x i32> %162, %176
%179 = add <2 x i32> %163, %177
br label %180
180: ; preds = %158, %165
%181 = phi <2 x i32> [ %159, %158 ], [ %178, %165 ]
%182 = phi <2 x i32> [ %160, %158 ], [ %179, %165 ]
%183 = add <2 x i32> %182, %181
%184 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %183)
%185 = icmp eq i64 %105, %20
br i1 %185, label %205, label %186
186: ; preds = %100, %180
%187 = phi i64 [ 0, %100 ], [ %105, %180 ]
%188 = phi i32 [ 0, %100 ], [ %184, %180 ]
br label %227
189: ; preds = %94, %189
%190 = phi i64 [ %197, %189 ], [ %95, %94 ]
%191 = phi i32 [ %196, %189 ], [ %96, %94 ]
%192 = getelementptr inbounds double, double* %0, i64 %190
%193 = load double, double* %192
%194 = fcmp ogt double %193, %2
%195 = zext i1 %194 to i32
%196 = add i32 %191, %195
%197 = add nuw nsw i64 %190, 1
%198 = icmp eq i64 %197, %20
br i1 %198, label %97, label %189
199: ; preds = %97, %4
%200 = phi double [ %99, %97 ], [ 0.000000e+00, %4 ]
%201 = fsub double 1.000000e+00, %2
%202 = uitofp i32 %1 to double
%203 = fmul double %201, %202
%204 = fdiv double %200, %203
br label %213
205: ; preds = %227, %180
%206 = phi i32 [ %184, %180 ], [ %235, %227 ]
%207 = fsub double 1.000000e+00, %2
%208 = uitofp i32 %1 to double
%209 = fmul double %207, %208
%210 = fdiv double %99, %209
%211 = icmp eq i32 %206, 0
%212 = uitofp i32 %206 to double
br i1 %211, label %213, label %216
213: ; preds = %199, %205
%214 = phi double [ %204, %199 ], [ %210, %205 ]
%215 = phi double [ %202, %199 ], [ %208, %205 ]
br label %216
216: ; preds = %205, %213
%217 = phi double [ %214, %213 ], [ %210, %205 ]
%218 = phi double [ %215, %213 ], [ %208, %205 ]
%219 = phi double [ 1.000000e+00, %213 ], [ %212, %205 ]
%220 = fdiv double %219, %218
%221 = fmul double %217, %3
%222 = fneg double %3
%223 = tail call double @pow1pm1(double %222, double %218)
%224 = fneg double %223
%225 = fmul double %220, %224
%226 = fdiv double %221, %225
ret double %226
227: ; preds = %186, %227
%228 = phi i64 [ %236, %227 ], [ %187, %186 ]
%229 = phi i32 [ %235, %227 ], [ %188, %186 ]
%230 = getelementptr inbounds double, double* %0, i64 %228
%231 = load double, double* %230
%232 = fsub double %231, %3
%233 = fcmp ole double %232, %101
%234 = zext i1 %233 to i32
%235 = add i32 %229, %234
%236 = add nuw nsw i64 %228, 1
%237 = icmp eq i64 %236, %102
br i1 %237, label %205, label %227
}