#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 */
float sqrt(float);
void tptest(float data1[], float data2[], unsigned long n, float *t,
            float *prob) {
  void avevar(float data[], unsigned long n, float *ave, float *var);
  float betai(float a, float b, float x);
  unsigned long j;
  float var1, var2, ave1, ave2, sd, df, cov = 0.0;
  avevar(data1, n, &ave1, &var1);
  avevar(data2, n, &ave2, &var2);
  for (j = 1; j <= n; j++)
    cov += (data1[j] - ave1) * (data2[j] - ave2);
  cov /= df = n - 1;
  sd = sqrt((var1 + var2 - 2.0 * cov) / n);
  *t = (ave1 - ave2) / sd;
  *prob = betai(0.5 * df, 0.5, df / (df + (*t) * (*t)));
}


x86 assembly (clang, -O0):
<tptest>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0x3c(%rbp),%rdx
lea    -0x34(%rbp),%rcx
call   1030 <avevar@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0x40(%rbp),%rdx
lea    -0x38(%rbp),%rcx
call   1030 <avevar@plt>
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
ja     11db <tptest+0xab>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
subss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1186 <tptest+0x56>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%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,-0x54(%rbp)
test   %rax,%rax
movss  %xmm0,-0x50(%rbp)
js     121c <tptest+0xec>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm1
movss  %xmm1,-0x48(%rbp)
movss  -0x4c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
movaps 0xdb2(%rip),%xmm2
movq   -0x18(%rbp),%xmm1
punpckldq %xmm2,%xmm1
movapd 0xdb1(%rip),%xmm2
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1050 <sqrt@plt>
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
divss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd50(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x48(%rbp),%xmm3
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
divss  %xmm1,%xmm2
movss  0xd12(%rip),%xmm1
call   1040 <betai@plt>
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tptest>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x20,%rsp
mov    %r8,%r14
mov    %rcx,%r15
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%rbx
lea    0x10(%rsp),%rdx
lea    0x1c(%rsp),%rcx
mov    %r12,%rsi
call   1030 <avevar@plt>
lea    0xc(%rsp),%rdx
lea    0x18(%rsp),%rcx
mov    %r13,%rdi
mov    %r12,%rsi
call   1030 <avevar@plt>
test   %r12,%r12
je     1194 <tptest+0x64>
movss  0x10(%rsp),%xmm2
movss  0xc(%rsp),%xmm1
cmp    $0x1,%r12
jne    119c <tptest+0x6c>
mov    $0x1,%eax
xorps  %xmm0,%xmm0
jmp    11fe <tptest+0xce>
xorps  %xmm0,%xmm0
jmp    1220 <tptest+0xf0>
mov    %r12,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
mov    $0x1,%eax
xorps  %xmm3,%xmm3
xchg   %ax,%ax
movss  (%rbx,%rax,4),%xmm4
movss  0x4(%rbx,%rax,4),%xmm5
subss  %xmm2,%xmm4
movss  0x0(%r13,%rax,4),%xmm6
movss  0x4(%r13,%rax,4),%xmm0
subss  %xmm1,%xmm6
mulss  %xmm4,%xmm6
addss  %xmm3,%xmm6
subss  %xmm2,%xmm5
subss  %xmm1,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm6,%xmm0
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
movaps %xmm0,%xmm3
cmp    $0x1,%rdx
jne    11b0 <tptest+0x80>
test   $0x1,%r12b
je     1220 <tptest+0xf0>
movss  (%rbx,%rax,4),%xmm3
subss  %xmm2,%xmm3
movss  0x0(%r13,%rax,4),%xmm2
subss  %xmm1,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm2,%xmm0
mov    %r12,%rax
add    $0xffffffffffffffff,%rax
js     1233 <tptest+0x103>
xorps  %xmm2,%xmm2
cvtsi2ss %rax,%xmm2
jmp    124b <tptest+0x11b>
mov    %rax,%rcx
shr    %rcx
and    $0x1,%eax
or     %rcx,%rax
xorps  %xmm2,%xmm2
cvtsi2ss %rax,%xmm2
addss  %xmm2,%xmm2
divss  %xmm2,%xmm0
movss  0x1c(%rsp),%xmm1
addss  0x18(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
movq   %r12,%xmm3
punpckldq 0xd8c(%rip),%xmm3
subsd  %xmm0,%xmm1
subpd  0xd90(%rip),%xmm3
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
addsd  %xmm3,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     12a5 <tptest+0x175>
sqrtss %xmm0,%xmm0
jmp    12b6 <tptest+0x186>
movss  %xmm2,0x14(%rsp)
call   1050 <sqrt@plt>
movss  0x14(%rsp),%xmm2
movss  0x10(%rsp),%xmm3
subss  0xc(%rsp),%xmm3
divss  %xmm0,%xmm3
movss  %xmm3,(%r15)
movss  0xd4d(%rip),%xmm1
movaps %xmm2,%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm3,%xmm3
addss  %xmm2,%xmm3
divss  %xmm3,%xmm2
call   1040 <betai@plt>
movss  %xmm0,(%r14)
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @tptest(float* %0, float* %1, i64 %2, float* %3, float* %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca i64
%9 = alloca float*
%10 = alloca float*
%11 = alloca i64
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
store float* %0, float** %6
store float* %1, float** %7
store i64 %2, i64* %8
store float* %3, float** %9
store float* %4, float** %10
store float 0.000000e+00, float* %18
%19 = load float*, float** %6
%20 = load i64, i64* %8
%21 = load float*, float** %7
%22 = load i64, i64* %8
store i64 1, i64* %11
br label %23
23: ; preds = %42, %5
%24 = load i64, i64* %11
%25 = load i64, i64* %8
%26 = icmp ule i64 %24, %25
br i1 %26, label %27, label %45
27: ; preds = %23
%28 = load float*, float** %6
%29 = load i64, i64* %11
%30 = getelementptr inbounds float, float* %28, i64 %29
%31 = load float, float* %30
%32 = load float, float* %14
%33 = fsub float %31, %32
%34 = load float*, float** %7
%35 = load i64, i64* %11
%36 = getelementptr inbounds float, float* %34, i64 %35
%37 = load float, float* %36
%38 = load float, float* %15
%39 = fsub float %37, %38
%40 = load float, float* %18
%41 = call float @llvm.fmuladd.f32(float %33, float %39, float %40)
store float %41, float* %18
br label %42
42: ; preds = %27
%43 = load i64, i64* %11
%44 = add i64 %43, 1
store i64 %44, i64* %11
br label %23
45: ; preds = %23
%46 = load i64, i64* %8
%47 = sub i64 %46, 1
%48 = uitofp i64 %47 to float
store float %48, float* %17
%49 = load float, float* %18
%50 = fdiv float %49, %48
store float %50, float* %18
%51 = load float, float* %12
%52 = load float, float* %13
%53 = fadd float %51, %52
%54 = fpext float %53 to double
%55 = load float, float* %18
%56 = fpext float %55 to double
%57 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %56, double %54)
%58 = load i64, i64* %8
%59 = uitofp i64 %58 to double
%60 = fdiv double %57, %59
%61 = fptrunc double %60 to float
%62 = call float @sqrt(float %61)
store float %62, float* %16
%63 = load float, float* %14
%64 = load float, float* %15
%65 = fsub float %63, %64
%66 = load float, float* %16
%67 = fdiv float %65, %66
%68 = load float*, float** %9
store float %67, float* %68
%69 = load float, float* %17
%70 = fpext float %69 to double
%71 = fmul double 5.000000e-01, %70
%72 = fptrunc double %71 to float
%73 = load float, float* %17
%74 = load float, float* %17
%75 = load float*, float** %9
%76 = load float, float* %75
%77 = load float*, float** %9
%78 = load float, float* %77
%79 = call float @llvm.fmuladd.f32(float %76, float %78, float %74)
%80 = fdiv float %73, %79
%81 = call float @betai(float %72, float 5.000000e-01, float %80)
%82 = load float*, float** %10
store float %81, float* %82
ret void
}

LLVM IR (-O2):
define void @tptest(float* %0, float* %1, i64 %2, float* nocapture writeonly %3, float* nocapture writeonly %4) {
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = bitcast float* %6 to i8*
%11 = bitcast float* %7 to i8*
%12 = bitcast float* %8 to i8*
%13 = bitcast float* %9 to i8*
%14 = icmp eq i64 %2, 0
br i1 %14, label %57, label %15
15: ; preds = %5
%16 = load float, float* %8
%17 = load float, float* %9
%18 = and i64 %2, 1
%19 = icmp eq i64 %2, 1
br i1 %19, label %44, label %20
20: ; preds = %15
%21 = and i64 %2, -2
br label %22
22: ; preds = %22, %20
%23 = phi float [ 0.000000e+00, %20 ], [ %40, %22 ]
%24 = phi i64 [ 1, %20 ], [ %41, %22 ]
%25 = phi i64 [ 0, %20 ], [ %42, %22 ]
%26 = getelementptr inbounds float, float* %0, i64 %24
%27 = load float, float* %26
%28 = fsub float %27, %16
%29 = getelementptr inbounds float, float* %1, i64 %24
%30 = load float, float* %29
%31 = fsub float %30, %17
%32 = call float @llvm.fmuladd.f32(float %28, float %31, float %23)
%33 = add nuw i64 %24, 1
%34 = getelementptr inbounds float, float* %0, i64 %33
%35 = load float, float* %34
%36 = fsub float %35, %16
%37 = getelementptr inbounds float, float* %1, i64 %33
%38 = load float, float* %37
%39 = fsub float %38, %17
%40 = call float @llvm.fmuladd.f32(float %36, float %39, float %32)
%41 = add nuw i64 %24, 2
%42 = add i64 %25, 2
%43 = icmp eq i64 %42, %21
br i1 %43, label %44, label %22
44: ; preds = %22, %15
%45 = phi float [ undef, %15 ], [ %40, %22 ]
%46 = phi float [ 0.000000e+00, %15 ], [ %40, %22 ]
%47 = phi i64 [ 1, %15 ], [ %41, %22 ]
%48 = icmp eq i64 %18, 0
br i1 %48, label %57, label %49
49: ; preds = %44
%50 = getelementptr inbounds float, float* %0, i64 %47
%51 = load float, float* %50
%52 = fsub float %51, %16
%53 = getelementptr inbounds float, float* %1, i64 %47
%54 = load float, float* %53
%55 = fsub float %54, %17
%56 = call float @llvm.fmuladd.f32(float %52, float %55, float %46)
br label %57
57: ; preds = %49, %44, %5
%58 = phi float [ 0.000000e+00, %5 ], [ %45, %44 ], [ %56, %49 ]
%59 = add i64 %2, -1
%60 = uitofp i64 %59 to float
%61 = fdiv float %58, %60
%62 = load float, float* %6
%63 = load float, float* %7
%64 = fadd float %62, %63
%65 = fpext float %64 to double
%66 = fpext float %61 to double
%67 = call double @llvm.fmuladd.f64(double %66, double -2.000000e+00, double %65)
%68 = uitofp i64 %2 to double
%69 = fdiv double %67, %68
%70 = fptrunc double %69 to float
%71 = call float @sqrt(float %70)
%72 = load float, float* %8
%73 = load float, float* %9
%74 = fsub float %72, %73
%75 = fdiv float %74, %71
store float %75, float* %3
%76 = fmul float %60, 5.000000e-01
%77 = call float @llvm.fmuladd.f32(float %75, float %75, float %60)
%78 = fdiv float %60, %77
%79 = call float @betai(float %76, float 5.000000e-01, float %78)
store float %79, float* %4
ret void
}