#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 log(double);
float sqrt(float);
void pearsn(float x[], float y[], unsigned long n, float *r, float *prob,
            float *z) {
  float betai(float a, float b, float x);
  float erfcc(float x);
  unsigned long j;
  float yt, xt, t, df;
  float syy = 0.0, sxy = 0.0, sxx = 0.0, ay = 0.0, ax = 0.0;
  for (j = 1; j <= n; j++) {
    ax += x[j];
    ay += y[j];
  }
  ax /= n;
  ay /= n;
  for (j = 1; j <= n; j++) {
    xt = x[j] - ax;
    yt = y[j] - ay;
    sxx += xt * xt;
    syy += yt * yt;
    sxy += xt * yt;
  }
  *r = sxy / (sqrt(sxx * syy) + 1.0e-20);
  *z = 0.5 * log((1.0 + (*r) + 1.0e-20) / (1.0 - (*r) + 1.0e-20));
  df = n - 2;
  t = (*r) * sqrt(df / ((1.0 - (*r) + 1.0e-20) * (1.0 + (*r) + 1.0e-20)));
  *prob = betai(0.5 * df, 0.5, df / (df + t * t));
}


x86 assembly (clang, -O0):
<pearsn>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
ja     11d0 <pearsn+0xa0>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1183 <pearsn+0x53>
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x64(%rbp)
test   %rax,%rax
movss  %xmm0,-0x60(%rbp)
js     120d <pearsn+0xdd>
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x6c(%rbp)
test   %rax,%rax
movss  %xmm0,-0x68(%rbp)
js     125d <pearsn+0x12d>
movss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
ja     1319 <pearsn+0x1e9>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1278 <pearsn+0x148>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
mulss  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
cvtss2sd %xmm1,%xmm1
movsd  0xcc2(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm3
movsd  0xca2(%rip),%xmm1
movaps %xmm3,%xmm0
addsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
subsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
movsd  0xc6e(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x74(%rbp)
test   %rax,%rax
movss  %xmm0,-0x70(%rbp)
js     13eb <pearsn+0x2bb>
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xbf6(%rip),%xmm1
subsd  %xmm2,%xmm1
movsd  0xbe2(%rip),%xmm2
addsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
cvtss2sd %xmm2,%xmm3
movsd  0xbd2(%rip),%xmm2
addsd  %xmm3,%xmm2
movsd  0xbbe(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb7c(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x48(%rbp),%xmm3
movss  -0x44(%rbp),%xmm1
movss  -0x44(%rbp),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
divss  %xmm1,%xmm2
movss  0xb44(%rip),%xmm1
call   1030 <betai@plt>
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pearsn>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %r9,%r12
mov    %r8,%r14
mov    %rcx,%r15
mov    %rdx,%r13
xorps  %xmm1,%xmm1
xorps  %xmm7,%xmm7
test   %rdx,%rdx
je     117a <pearsn+0x4a>
lea    -0x1(%r13),%r8
mov    %r13d,%ecx
and    $0x3,%ecx
cmp    $0x3,%r8
jae    118b <pearsn+0x5b>
xorps  %xmm2,%xmm2
mov    $0x1,%edx
test   %rcx,%rcx
jne    11fa <pearsn+0xca>
jmp    1229 <pearsn+0xf9>
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jae    1253 <pearsn+0x123>
jmp    1341 <pearsn+0x211>
mov    %r13,%rbx
and    $0xfffffffffffffffc,%rbx
xorps  %xmm2,%xmm2
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movss  0x4(%rsi,%rdx,4),%xmm0
movss  0x8(%rsi,%rdx,4),%xmm3
movss  0xc(%rsi,%rdx,4),%xmm4
movss  0x10(%rsi,%rdx,4),%xmm5
movss  0x4(%rdi,%rdx,4),%xmm6
unpcklps %xmm0,%xmm6
addps  %xmm2,%xmm6
movss  0x8(%rdi,%rdx,4),%xmm0
unpcklps %xmm3,%xmm0
addps  %xmm6,%xmm0
movss  0xc(%rdi,%rdx,4),%xmm3
unpcklps %xmm4,%xmm3
addps  %xmm0,%xmm3
movss  0x10(%rdi,%rdx,4),%xmm2
unpcklps %xmm5,%xmm2
addps  %xmm3,%xmm2
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    11a0 <pearsn+0x70>
add    $0x1,%rdx
test   %rcx,%rcx
je     1229 <pearsn+0xf9>
lea    (%rsi,%rdx,4),%rbx
lea    (%rdi,%rdx,4),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rbx,%rax,4),%xmm0
movss  (%rdx,%rax,4),%xmm3
unpcklps %xmm0,%xmm3
addps  %xmm3,%xmm2
add    $0x1,%rax
cmp    %rax,%rcx
jne    1210 <pearsn+0xe0>
mov    %r13,%rcx
shr    %rcx
mov    %r13d,%eax
and    $0x1,%eax
or     %rcx,%rax
test   %r13,%r13
js     125c <pearsn+0x12c>
xorps  %xmm3,%xmm3
cvtsi2ss %r13,%xmm3
xorps  %xmm0,%xmm0
jne    126d <pearsn+0x13d>
ucomiss %xmm1,%xmm0
jb     1341 <pearsn+0x211>
sqrtss %xmm0,%xmm0
jmp    1350 <pearsn+0x220>
xorps  %xmm3,%xmm3
cvtsi2ss %rax,%xmm3
addss  %xmm3,%xmm3
xorps  %xmm0,%xmm0
je     124a <pearsn+0x11a>
shufps $0x0,%xmm3,%xmm3
divps  %xmm3,%xmm2
test   %r8,%r8
je     1478 <pearsn+0x348>
mov    %r13,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
xorps  %xmm0,%xmm0
mov    $0x1,%eax
xorps  %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm4
movss  0x4(%rsi,%rax,4),%xmm5
movss  (%rdi,%rax,4),%xmm6
unpcklps %xmm4,%xmm6
subps  %xmm2,%xmm6
movaps %xmm6,%xmm4
shufps $0x55,%xmm6,%xmm4
mulps  %xmm6,%xmm4
mulss  %xmm6,%xmm6
addss  %xmm3,%xmm6
movss  0x4(%rdi,%rax,4),%xmm3
unpcklps %xmm5,%xmm3
addps  %xmm0,%xmm4
subps  %xmm2,%xmm3
movaps %xmm3,%xmm0
shufps $0x55,%xmm3,%xmm0
mulps  %xmm3,%xmm0
mulss  %xmm3,%xmm3
addss  %xmm6,%xmm3
addps  %xmm4,%xmm0
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    12a0 <pearsn+0x170>
test   $0x1,%r13b
je     1329 <pearsn+0x1f9>
movss  (%rsi,%rax,4),%xmm4
movss  (%rdi,%rax,4),%xmm5
unpcklps %xmm4,%xmm5
subps  %xmm2,%xmm5
movaps %xmm5,%xmm2
shufps $0x55,%xmm5,%xmm2
mulps  %xmm5,%xmm2
mulss  %xmm5,%xmm5
addss  %xmm5,%xmm3
addps  %xmm2,%xmm0
xorps  %xmm7,%xmm7
cvtss2sd %xmm0,%xmm7
shufps $0x55,%xmm0,%xmm0
mulss  %xmm3,%xmm0
ucomiss %xmm1,%xmm0
jae    1253 <pearsn+0x123>
movsd  %xmm7,(%rsp)
call   1050 <sqrt@plt>
movsd  (%rsp),%xmm7
cvtss2sd %xmm0,%xmm0
movsd  0xca4(%rip),%xmm2
addsd  %xmm2,%xmm0
divsd  %xmm0,%xmm7
xorps  %xmm0,%xmm0
cvtsd2ss %xmm7,%xmm0
movss  %xmm0,(%r15)
cvtss2sd %xmm0,%xmm0
movsd  0xc8c(%rip),%xmm3
movapd %xmm3,%xmm1
subsd  %xmm0,%xmm1
addsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
mulsd  0xc6f(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r12)
add    $0xfffffffffffffffe,%r13
js     13bb <pearsn+0x28b>
xorps  %xmm2,%xmm2
cvtsi2ss %r13,%xmm2
jmp    13d4 <pearsn+0x2a4>
mov    %r13,%rax
shr    %rax
and    $0x1,%r13d
or     %rax,%r13
xorps  %xmm2,%xmm2
cvtsi2ss %r13,%xmm2
addss  %xmm2,%xmm2
movss  (%r15),%xmm6
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm6,%xmm1
movsd  0xc19(%rip),%xmm5
movapd %xmm5,%xmm4
subsd  %xmm1,%xmm4
movsd  0xc01(%rip),%xmm3
addsd  %xmm3,%xmm4
addsd  %xmm5,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm4,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
xorpd  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1426 <pearsn+0x2f6>
sqrtss %xmm0,%xmm0
jmp    1441 <pearsn+0x311>
movss  %xmm2,(%rsp)
movss  %xmm6,0xc(%rsp)
call   1050 <sqrt@plt>
movss  0xc(%rsp),%xmm6
movss  (%rsp),%xmm2
mulss  %xmm0,%xmm6
movss  0xbcb(%rip),%xmm1
movaps %xmm2,%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm6,%xmm6
addss  %xmm2,%xmm6
divss  %xmm6,%xmm2
call   1030 <betai@plt>
movss  %xmm0,(%r14)
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
xorps  %xmm0,%xmm0
mov    $0x1,%eax
xorps  %xmm3,%xmm3
test   $0x1,%r13b
jne    1304 <pearsn+0x1d4>
jmp    1329 <pearsn+0x1f9>

LLVM IR (-O0):
define void @pearsn(float* %0, float* %1, i64 %2, float* %3, float* %4, float* %5) {
%7 = alloca float*
%8 = alloca float*
%9 = alloca i64
%10 = alloca float*
%11 = alloca float*
%12 = alloca float*
%13 = alloca i64
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
store float* %0, float** %7
store float* %1, float** %8
store i64 %2, i64* %9
store float* %3, float** %10
store float* %4, float** %11
store float* %5, float** %12
store float 0.000000e+00, float* %18
store float 0.000000e+00, float* %19
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store i64 1, i64* %13
br label %23
23: ; preds = %40, %6
%24 = load i64, i64* %13
%25 = load i64, i64* %9
%26 = icmp ule i64 %24, %25
br i1 %26, label %27, label %43
27: ; preds = %23
%28 = load float*, float** %7
%29 = load i64, i64* %13
%30 = getelementptr inbounds float, float* %28, i64 %29
%31 = load float, float* %30
%32 = load float, float* %22
%33 = fadd float %32, %31
store float %33, float* %22
%34 = load float*, float** %8
%35 = load i64, i64* %13
%36 = getelementptr inbounds float, float* %34, i64 %35
%37 = load float, float* %36
%38 = load float, float* %21
%39 = fadd float %38, %37
store float %39, float* %21
br label %40
40: ; preds = %27
%41 = load i64, i64* %13
%42 = add i64 %41, 1
store i64 %42, i64* %13
br label %23
43: ; preds = %23
%44 = load i64, i64* %9
%45 = uitofp i64 %44 to float
%46 = load float, float* %22
%47 = fdiv float %46, %45
store float %47, float* %22
%48 = load i64, i64* %9
%49 = uitofp i64 %48 to float
%50 = load float, float* %21
%51 = fdiv float %50, %49
store float %51, float* %21
store i64 1, i64* %13
br label %52
52: ; preds = %81, %43
%53 = load i64, i64* %13
%54 = load i64, i64* %9
%55 = icmp ule i64 %53, %54
br i1 %55, label %56, label %84
56: ; preds = %52
%57 = load float*, float** %7
%58 = load i64, i64* %13
%59 = getelementptr inbounds float, float* %57, i64 %58
%60 = load float, float* %59
%61 = load float, float* %22
%62 = fsub float %60, %61
store float %62, float* %15
%63 = load float*, float** %8
%64 = load i64, i64* %13
%65 = getelementptr inbounds float, float* %63, i64 %64
%66 = load float, float* %65
%67 = load float, float* %21
%68 = fsub float %66, %67
store float %68, float* %14
%69 = load float, float* %15
%70 = load float, float* %15
%71 = load float, float* %20
%72 = call float @llvm.fmuladd.f32(float %69, float %70, float %71)
store float %72, float* %20
%73 = load float, float* %14
%74 = load float, float* %14
%75 = load float, float* %18
%76 = call float @llvm.fmuladd.f32(float %73, float %74, float %75)
store float %76, float* %18
%77 = load float, float* %15
%78 = load float, float* %14
%79 = load float, float* %19
%80 = call float @llvm.fmuladd.f32(float %77, float %78, float %79)
store float %80, float* %19
br label %81
81: ; preds = %56
%82 = load i64, i64* %13
%83 = add i64 %82, 1
store i64 %83, i64* %13
br label %52
84: ; preds = %52
%85 = load float, float* %19
%86 = fpext float %85 to double
%87 = load float, float* %20
%88 = load float, float* %18
%89 = fmul float %87, %88
%90 = call float @sqrt(float %89)
%91 = fpext float %90 to double
%92 = fadd double %91, 0x3BC79CA10C924223
%93 = fdiv double %86, %92
%94 = fptrunc double %93 to float
%95 = load float*, float** %10
store float %94, float* %95
%96 = load float*, float** %10
%97 = load float, float* %96
%98 = fpext float %97 to double
%99 = fadd double 1.000000e+00, %98
%100 = fadd double %99, 0x3BC79CA10C924223
%101 = load float*, float** %10
%102 = load float, float* %101
%103 = fpext float %102 to double
%104 = fsub double 1.000000e+00, %103
%105 = fadd double %104, 0x3BC79CA10C924223
%106 = fdiv double %100, %105
%107 = call double @log(double %106)
%108 = fmul double 5.000000e-01, %107
%109 = fptrunc double %108 to float
%110 = load float*, float** %12
store float %109, float* %110
%111 = load i64, i64* %9
%112 = sub i64 %111, 2
%113 = uitofp i64 %112 to float
store float %113, float* %17
%114 = load float*, float** %10
%115 = load float, float* %114
%116 = load float, float* %17
%117 = fpext float %116 to double
%118 = load float*, float** %10
%119 = load float, float* %118
%120 = fpext float %119 to double
%121 = fsub double 1.000000e+00, %120
%122 = fadd double %121, 0x3BC79CA10C924223
%123 = load float*, float** %10
%124 = load float, float* %123
%125 = fpext float %124 to double
%126 = fadd double 1.000000e+00, %125
%127 = fadd double %126, 0x3BC79CA10C924223
%128 = fmul double %122, %127
%129 = fdiv double %117, %128
%130 = fptrunc double %129 to float
%131 = call float @sqrt(float %130)
%132 = fmul float %115, %131
store float %132, float* %16
%133 = load float, float* %17
%134 = fpext float %133 to double
%135 = fmul double 5.000000e-01, %134
%136 = fptrunc double %135 to float
%137 = load float, float* %17
%138 = load float, float* %17
%139 = load float, float* %16
%140 = load float, float* %16
%141 = call float @llvm.fmuladd.f32(float %139, float %140, float %138)
%142 = fdiv float %137, %141
%143 = call float @betai(float %136, float 5.000000e-01, float %142)
%144 = load float*, float** %11
store float %143, float* %144
ret void
}

LLVM IR (-O2):
define void @pearsn(float* nocapture %0, float* nocapture %1, i64 %2, float* nocapture %3, float* nocapture writeonly %4, float* nocapture writeonly %5) {
%7 = icmp eq i64 %2, 0
br i1 %7, label %139, label %8
8: ; preds = %6
%9 = add i64 %2, -1
%10 = and i64 %2, 3
%11 = icmp ult i64 %9, 3
br i1 %11, label %52, label %12
12: ; preds = %8
%13 = and i64 %2, -4
br label %14
14: ; preds = %14, %12
%15 = phi i64 [ 1, %12 ], [ %49, %14 ]
%16 = phi <2 x float> [ zeroinitializer, %12 ], [ %48, %14 ]
%17 = phi i64 [ 0, %12 ], [ %50, %14 ]
%18 = getelementptr inbounds float, float* %0, i64 %15
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %1, i64 %15
%21 = load float, float* %20
%22 = insertelement <2 x float> poison, float %19, i64 0
%23 = insertelement <2 x float> %22, float %21, i64 1
%24 = fadd <2 x float> %16, %23
%25 = add nuw nsw i64 %15, 1
%26 = getelementptr inbounds float, float* %0, i64 %25
%27 = load float, float* %26
%28 = getelementptr inbounds float, float* %1, i64 %25
%29 = load float, float* %28
%30 = insertelement <2 x float> poison, float %27, i64 0
%31 = insertelement <2 x float> %30, float %29, i64 1
%32 = fadd <2 x float> %24, %31
%33 = add nuw nsw i64 %15, 2
%34 = getelementptr inbounds float, float* %0, i64 %33
%35 = load float, float* %34
%36 = getelementptr inbounds float, float* %1, i64 %33
%37 = load float, float* %36
%38 = insertelement <2 x float> poison, float %35, i64 0
%39 = insertelement <2 x float> %38, float %37, i64 1
%40 = fadd <2 x float> %32, %39
%41 = add nuw i64 %15, 3
%42 = getelementptr inbounds float, float* %0, i64 %41
%43 = load float, float* %42
%44 = getelementptr inbounds float, float* %1, i64 %41
%45 = load float, float* %44
%46 = insertelement <2 x float> poison, float %43, i64 0
%47 = insertelement <2 x float> %46, float %45, i64 1
%48 = fadd <2 x float> %40, %47
%49 = add nuw i64 %15, 4
%50 = add i64 %17, 4
%51 = icmp eq i64 %50, %13
br i1 %51, label %52, label %14
52: ; preds = %14, %8
%53 = phi <2 x float> [ undef, %8 ], [ %48, %14 ]
%54 = phi i64 [ 1, %8 ], [ %49, %14 ]
%55 = phi <2 x float> [ zeroinitializer, %8 ], [ %48, %14 ]
%56 = icmp eq i64 %10, 0
br i1 %56, label %71, label %57
57: ; preds = %52, %57
%58 = phi i64 [ %68, %57 ], [ %54, %52 ]
%59 = phi <2 x float> [ %67, %57 ], [ %55, %52 ]
%60 = phi i64 [ %69, %57 ], [ 0, %52 ]
%61 = getelementptr inbounds float, float* %0, i64 %58
%62 = load float, float* %61
%63 = getelementptr inbounds float, float* %1, i64 %58
%64 = load float, float* %63
%65 = insertelement <2 x float> poison, float %62, i64 0
%66 = insertelement <2 x float> %65, float %64, i64 1
%67 = fadd <2 x float> %59, %66
%68 = add nuw i64 %58, 1
%69 = add i64 %60, 1
%70 = icmp eq i64 %69, %10
br i1 %70, label %71, label %57
71: ; preds = %57, %52
%72 = phi <2 x float> [ %53, %52 ], [ %67, %57 ]
%73 = uitofp i64 %2 to float
%74 = insertelement <2 x float> poison, float %73, i64 0
%75 = shufflevector <2 x float> %74, <2 x float> poison, <2 x i32> zeroinitializer
%76 = fdiv <2 x float> %72, %75
br i1 %7, label %139, label %77
77: ; preds = %71
%78 = and i64 %2, 1
%79 = icmp eq i64 %9, 0
br i1 %79, label %113, label %80
80: ; preds = %77
%81 = and i64 %2, -2
br label %82
82: ; preds = %82, %80
%83 = phi float [ 0.000000e+00, %80 ], [ %107, %82 ]
%84 = phi i64 [ 1, %80 ], [ %110, %82 ]
%85 = phi <2 x float> [ zeroinitializer, %80 ], [ %109, %82 ]
%86 = phi i64 [ 0, %80 ], [ %111, %82 ]
%87 = getelementptr inbounds float, float* %0, i64 %84
%88 = load float, float* %87
%89 = getelementptr inbounds float, float* %1, i64 %84
%90 = load float, float* %89
%91 = insertelement <2 x float> poison, float %88, i64 0
%92 = insertelement <2 x float> %91, float %90, i64 1
%93 = fsub <2 x float> %92, %76
%94 = extractelement <2 x float> %93, i64 0
%95 = tail call float @llvm.fmuladd.f32(float %94, float %94, float %83)
%96 = shufflevector <2 x float> %93, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%97 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %93, <2 x float> %96, <2 x float> %85)
%98 = add nuw i64 %84, 1
%99 = getelementptr inbounds float, float* %0, i64 %98
%100 = load float, float* %99
%101 = getelementptr inbounds float, float* %1, i64 %98
%102 = load float, float* %101
%103 = insertelement <2 x float> poison, float %100, i64 0
%104 = insertelement <2 x float> %103, float %102, i64 1
%105 = fsub <2 x float> %104, %76
%106 = extractelement <2 x float> %105, i64 0
%107 = tail call float @llvm.fmuladd.f32(float %106, float %106, float %95)
%108 = shufflevector <2 x float> %105, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%109 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %105, <2 x float> %108, <2 x float> %97)
%110 = add nuw i64 %84, 2
%111 = add i64 %86, 2
%112 = icmp eq i64 %111, %81
br i1 %112, label %113, label %82
113: ; preds = %82, %77
%114 = phi float [ undef, %77 ], [ %107, %82 ]
%115 = phi <2 x float> [ undef, %77 ], [ %109, %82 ]
%116 = phi float [ 0.000000e+00, %77 ], [ %107, %82 ]
%117 = phi i64 [ 1, %77 ], [ %110, %82 ]
%118 = phi <2 x float> [ zeroinitializer, %77 ], [ %109, %82 ]
%119 = icmp eq i64 %78, 0
br i1 %119, label %132, label %120
120: ; preds = %113
%121 = getelementptr inbounds float, float* %0, i64 %117
%122 = load float, float* %121
%123 = getelementptr inbounds float, float* %1, i64 %117
%124 = load float, float* %123
%125 = insertelement <2 x float> poison, float %122, i64 0
%126 = insertelement <2 x float> %125, float %124, i64 1
%127 = fsub <2 x float> %126, %76
%128 = extractelement <2 x float> %127, i64 0
%129 = tail call float @llvm.fmuladd.f32(float %128, float %128, float %116)
%130 = shufflevector <2 x float> %127, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%131 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %127, <2 x float> %130, <2 x float> %118)
br label %132
132: ; preds = %113, %120
%133 = phi float [ %114, %113 ], [ %129, %120 ]
%134 = phi <2 x float> [ %115, %113 ], [ %131, %120 ]
%135 = extractelement <2 x float> %134, i64 0
%136 = fpext float %135 to double
%137 = extractelement <2 x float> %134, i64 1
%138 = fmul float %137, %133
br label %139
139: ; preds = %6, %132, %71
%140 = phi double [ 0.000000e+00, %71 ], [ %136, %132 ], [ 0.000000e+00, %6 ]
%141 = phi float [ 0.000000e+00, %71 ], [ %138, %132 ], [ 0.000000e+00, %6 ]
%142 = tail call float @sqrt(float %141)
%143 = fpext float %142 to double
%144 = fadd double %143, 0x3BC79CA10C924223
%145 = fdiv double %140, %144
%146 = fptrunc double %145 to float
store float %146, float* %3
%147 = fpext float %146 to double
%148 = fadd double %147, 1.000000e+00
%149 = fadd double %148, 0x3BC79CA10C924223
%150 = fsub double 1.000000e+00, %147
%151 = fadd double %150, 0x3BC79CA10C924223
%152 = fdiv double %149, %151
%153 = tail call double @log(double %152)
%154 = fmul double %153, 5.000000e-01
%155 = fptrunc double %154 to float
store float %155, float* %5
%156 = add i64 %2, -2
%157 = uitofp i64 %156 to float
%158 = load float, float* %3
%159 = fpext float %157 to double
%160 = fpext float %158 to double
%161 = fsub double 1.000000e+00, %160
%162 = fadd double %161, 0x3BC79CA10C924223
%163 = fadd double %160, 1.000000e+00
%164 = fadd double %163, 0x3BC79CA10C924223
%165 = fmul double %162, %164
%166 = fdiv double %159, %165
%167 = fptrunc double %166 to float
%168 = tail call float @sqrt(float %167)
%169 = fmul float %158, %168
%170 = fmul float %157, 5.000000e-01
%171 = tail call float @llvm.fmuladd.f32(float %169, float %169, float %157)
%172 = fdiv float %157, %171
%173 = tail call float @betai(float %170, float 5.000000e-01, float %172)
store float %173, float* %4
ret void
}