#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 FLT_MIN;
int /*<<< orphan*/ assert(int);
float *calloc(size_t, int);
float fabs(float const);
float fmaxf(float, float const);
float sqrt(float);
float *compute_tstat(const double *sum, const double *sumsq, size_t d_length,
                     size_t w_length) {
  assert(d_length > 0);
  assert(w_length > 0);
  if (NULL == sum) {
    return NULL;
  };
  if (NULL == sumsq) {
    return NULL;
  };
  float *tstat = calloc(d_length, sizeof(float));
  if (NULL == tstat) {
    return NULL;
  };
  const float eta = FLT_MIN;
  const float w_lengthf = (float)w_length;
  if (d_length < 2 * w_length || w_length < 2) {
    for (size_t i = 0; i < d_length; ++i) {
      tstat[i] = 0.0f;
    }
    return tstat;
  }
  for (size_t i = 0; i < w_length; ++i) {
    tstat[i] = 0;
    tstat[d_length - i - 1] = 0;
  }
  for (size_t i = w_length; i <= d_length - w_length; ++i) {
    double sum1 = sum[i];
    double sumsq1 = sumsq[i];
    if (i > w_length) {
      sum1 -= sum[i - w_length];
      sumsq1 -= sumsq[i - w_length];
    }
    float sum2 = (float)(sum[i + w_length] - sum[i]);
    float sumsq2 = (float)(sumsq[i + w_length] - sumsq[i]);
    float mean1 = sum1 / w_lengthf;
    float mean2 = sum2 / w_lengthf;
    float combined_var =
        sumsq1 / w_lengthf - mean1 * mean1 + sumsq2 / w_lengthf - mean2 * mean2;
    combined_var = fmaxf(combined_var, eta);
    const float delta_mean = mean2 - mean1;
    tstat[i] = fabs(delta_mean) / sqrt(combined_var / w_lengthf);
  }
  return tstat;
}


x86 assembly (clang, -O0):
<compute_tstat>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
cmpq   $0x0,-0x20(%rbp)
seta   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
cmpq   $0x0,-0x28(%rbp)
seta   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
xor    %eax,%eax
cmp    -0x10(%rbp),%rax
jne    1198 <compute_tstat+0x58>
movq   $0x0,-0x8(%rbp)
jmp    14ce <compute_tstat+0x38e>
xor    %eax,%eax
cmp    -0x18(%rbp),%rax
jne    11b1 <compute_tstat+0x71>
movq   $0x0,-0x8(%rbp)
jmp    14ce <compute_tstat+0x38e>
mov    -0x20(%rbp),%rdi
mov    $0x4,%esi
call   1030 <calloc@plt>
mov    %rax,-0x30(%rbp)
xor    %eax,%eax
cmp    -0x30(%rbp),%rax
jne    11dc <compute_tstat+0x9c>
movq   $0x0,-0x8(%rbp)
jmp    14ce <compute_tstat+0x38e>
mov    0x2e05(%rip),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x28(%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,-0x80(%rbp)
test   %rax,%rax
movss  %xmm0,-0x7c(%rbp)
js     1229 <compute_tstat+0xe9>
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jb     1253 <compute_tstat+0x113>
cmpq   $0x2,-0x28(%rbp)
jae    1297 <compute_tstat+0x157>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    128a <compute_tstat+0x14a>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    125b <compute_tstat+0x11b>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    14ce <compute_tstat+0x38e>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    12e6 <compute_tstat+0x1a6>
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    -0x48(%rbp),%rcx
sub    $0x1,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    129f <compute_tstat+0x15f>
mov    -0x28(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    -0x28(%rbp),%rcx
cmp    %rcx,%rax
ja     14c6 <compute_tstat+0x386>
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x28(%rbp),%rax
jbe    1373 <compute_tstat+0x233>
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x64(%rbp),%xmm0
divss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movss  -0x6c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movss  -0x68(%rbp),%xmm1
divss  -0x38(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movss  -0x70(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm3
movss  -0x34(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordss %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxss  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x70(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x74(%rbp),%xmm0
divss  -0x38(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    12ee <compute_tstat+0x1ae>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_tstat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%r15
mov    %rdx,%r14
mov    %rsi,%r12
mov    %rdi,%rbp
xor    %edi,%edi
test   %rdx,%rdx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
test   %r15,%r15
setne  %dil
call   1050 <assert@plt>
xor    %ebx,%ebx
mov    %rbp,0x10(%rsp)
test   %rbp,%rbp
je     1421 <compute_tstat+0x2e1>
test   %r12,%r12
je     1421 <compute_tstat+0x2e1>
mov    %r14,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
test   %rax,%rax
je     11b9 <compute_tstat+0x79>
mov    %rax,%rbx
test   %r15,%r15
js     11c0 <compute_tstat+0x80>
cvtsi2ss %r15,%xmm5
cmp    $0x2,%r15
jae    11e2 <compute_tstat+0xa2>
jmp    1404 <compute_tstat+0x2c4>
xor    %ebx,%ebx
jmp    1421 <compute_tstat+0x2e1>
mov    %r15,%rax
shr    %rax
mov    %r15d,%ecx
and    $0x1,%ecx
or     %rax,%rcx
cvtsi2ss %rcx,%xmm5
addss  %xmm5,%xmm5
cmp    $0x2,%r15
jb     1404 <compute_tstat+0x2c4>
lea    (%r15,%r15,1),%rax
cmp    %r14,%rax
ja     1404 <compute_tstat+0x2c4>
mov    0x2df2(%rip),%rax
movss  (%rax),%xmm6
mov    %r15,%rdx
and    $0xfffffffffffffffe,%rdx
lea    -0x1(%r14),%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movl   $0x0,(%rbx,%rcx,4)
movl   $0x0,(%rbx,%rax,4)
movl   $0x0,0x4(%rbx,%rcx,4)
movl   $0x0,-0x4(%rbx,%rax,4)
add    $0x2,%rcx
add    $0xfffffffffffffffe,%rax
cmp    %rcx,%rdx
jne    1210 <compute_tstat+0xd0>
test   $0x1,%r15b
je     124f <compute_tstat+0x10f>
movl   $0x0,(%rbx,%rcx,4)
movl   $0x0,(%rbx,%rax,4)
sub    %r15,%r14
cmp    %r15,%r14
jb     1421 <compute_tstat+0x2e1>
cvtss2sd %xmm5,%xmm7
mov    %r15,%rsi
shl    $0x4,%rsi
lea    (%r12,%rsi,1),%r13
mov    0x10(%rsp),%rax
add    %rax,%rsi
mov    %rbx,0x18(%rsp)
lea    (%rbx,%r15,4),%rbp
mov    %r12,0x38(%rsp)
lea    (%r12,%r15,8),%rdi
lea    (%rax,%r15,8),%rbx
xor    %r12d,%r12d
movaps 0xd6d(%rip),%xmm8
xorps  %xmm9,%xmm9
movss  %xmm5,0x8(%rsp)
movaps %xmm6,0x40(%rsp)
movsd  %xmm7,0x30(%rsp)
mov    %r15,0x28(%rsp)
mov    %r14,0x20(%rsp)
jmp    1336 <compute_tstat+0x1f6>
nopw   0x0(%rax,%rax,1)
mov    %rsi,%r14
mov    %rdi,%r15
movaps %xmm4,0x50(%rsp)
movss  %xmm3,0xc(%rsp)
call   1060 <sqrt@plt>
movss  0xc(%rsp),%xmm3
movaps 0x50(%rsp),%xmm4
xorps  %xmm9,%xmm9
movaps 0xd13(%rip),%xmm8
mov    %r15,%rdi
mov    %r14,%rsi
mov    0x20(%rsp),%r14
mov    0x28(%rsp),%r15
movsd  0x30(%rsp),%xmm7
movaps 0x40(%rsp),%xmm6
movss  0x8(%rsp),%xmm5
subss  %xmm3,%xmm4
andps  %xmm8,%xmm4
divss  %xmm0,%xmm4
movss  %xmm4,0x0(%rbp,%r12,4)
lea    (%r15,%r12,1),%rax
add    $0x1,%rax
add    $0x1,%r12
cmp    %r14,%rax
ja     141c <compute_tstat+0x2dc>
lea    (%r15,%r12,1),%rax
movsd  (%rbx,%r12,8),%xmm3
movsd  (%rdi,%r12,8),%xmm1
movapd %xmm1,%xmm0
movapd %xmm3,%xmm2
cmp    %r15,%rax
jbe    1371 <compute_tstat+0x231>
movapd %xmm3,%xmm2
mov    0x10(%rsp),%rax
subsd  (%rax,%r12,8),%xmm2
movapd %xmm1,%xmm0
mov    0x38(%rsp),%rax
subsd  (%rax,%r12,8),%xmm0
movsd  (%rsi,%r12,8),%xmm4
subsd  %xmm3,%xmm4
cvtsd2ss %xmm4,%xmm4
movsd  0x0(%r13,%r12,8),%xmm3
subsd  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
divsd  %xmm7,%xmm2
xorps  %xmm3,%xmm3
cvtsd2ss %xmm2,%xmm3
divss  %xmm5,%xmm4
divsd  %xmm7,%xmm0
movaps %xmm3,%xmm2
mulss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm0
divss  %xmm5,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movaps %xmm4,%xmm0
mulss  %xmm4,%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movaps %xmm6,%xmm1
maxss  %xmm0,%xmm1
cmpunordss %xmm0,%xmm0
movaps %xmm0,%xmm2
andnps %xmm1,%xmm2
andps  %xmm6,%xmm0
orps   %xmm2,%xmm0
divss  %xmm5,%xmm0
ucomiss %xmm9,%xmm0
jb     12c0 <compute_tstat+0x180>
sqrtss %xmm0,%xmm0
jmp    130e <compute_tstat+0x1ce>
test   %r14,%r14
je     1421 <compute_tstat+0x2e1>
shl    $0x2,%r14
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
jmp    1421 <compute_tstat+0x2e1>
mov    0x18(%rsp),%rbx
mov    %rbx,%rax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@FLT_MIN = global float 0.000000e+00
define float* @compute_tstat(double* %0, double* %1, i64 %2, i64 %3) {
%5 = icmp ne i64 %2, 0
%6 = zext i1 %5 to i32
%7 = tail call i32 @assert(i32 %6)
%8 = icmp ne i64 %3, 0
%9 = zext i1 %8 to i32
%10 = tail call i32 @assert(i32 %9)
%11 = icmp eq double* %0, null
%12 = icmp eq double* %1, null
%13 = or i1 %11, %12
br i1 %13, label %109, label %14
14: ; preds = %4
%15 = tail call float* @calloc(i64 %2, i32 4)
%16 = bitcast float* %15 to i8*
%17 = icmp eq float* %15, null
br i1 %17, label %109, label %18
18: ; preds = %14
%19 = load float, float* @FLT_MIN
%20 = uitofp i64 %3 to float
%21 = shl i64 %3, 1
%22 = icmp ugt i64 %21, %2
%23 = icmp ult i64 %3, 2
%24 = or i1 %23, %22
br i1 %24, label %28, label %25
25: ; preds = %18
%26 = and i64 %3, 1
%27 = and i64 %3, -2
br label %44
28: ; preds = %18
%29 = icmp eq i64 %2, 0
br i1 %29, label %109, label %30
30: ; preds = %28
%31 = shl nuw i64 %2, 2
br label %109
32: ; preds = %44
%33 = icmp eq i64 %26, 0
br i1 %33, label %39, label %34
34: ; preds = %32
%35 = getelementptr inbounds float, float* %15, i64 %56
store float 0.000000e+00, float* %35
%36 = xor i64 %56, -1
%37 = add i64 %36, %2
%38 = getelementptr inbounds float, float* %15, i64 %37
store float 0.000000e+00, float* %38
br label %39
39: ; preds = %32, %34
%40 = sub i64 %2, %3
%41 = icmp ult i64 %40, %3
br i1 %41, label %109, label %42
42: ; preds = %39
%43 = fpext float %20 to double
br label %59
44: ; preds = %44, %25
%45 = phi i64 [ 0, %25 ], [ %56, %44 ]
%46 = phi i64 [ 0, %25 ], [ %57, %44 ]
%47 = getelementptr inbounds float, float* %15, i64 %45
store float 0.000000e+00, float* %47
%48 = xor i64 %45, -1
%49 = add i64 %48, %2
%50 = getelementptr inbounds float, float* %15, i64 %49
store float 0.000000e+00, float* %50
%51 = or i64 %45, 1
%52 = getelementptr inbounds float, float* %15, i64 %51
store float 0.000000e+00, float* %52
%53 = sub nuw nsw i64 -2, %45
%54 = add i64 %53, %2
%55 = getelementptr inbounds float, float* %15, i64 %54
store float 0.000000e+00, float* %55
%56 = add nuw i64 %45, 2
%57 = add nuw i64 %46, 2
%58 = icmp eq i64 %57, %27
br i1 %58, label %32, label %44
59: ; preds = %42, %74
%60 = phi i64 [ %3, %42 ], [ %107, %74 ]
%61 = getelementptr inbounds double, double* %0, i64 %60
%62 = load double, double* %61
%63 = getelementptr inbounds double, double* %1, i64 %60
%64 = load double, double* %63
%65 = icmp ugt i64 %60, %3
br i1 %65, label %66, label %74
66: ; preds = %59
%67 = sub i64 %60, %3
%68 = getelementptr inbounds double, double* %0, i64 %67
%69 = load double, double* %68
%70 = fsub double %62, %69
%71 = getelementptr inbounds double, double* %1, i64 %67
%72 = load double, double* %71
%73 = fsub double %64, %72
br label %74
74: ; preds = %66, %59
%75 = phi double [ %73, %66 ], [ %64, %59 ]
%76 = phi double [ %70, %66 ], [ %62, %59 ]
%77 = add i64 %60, %3
%78 = getelementptr inbounds double, double* %0, i64 %77
%79 = load double, double* %78
%80 = fsub double %79, %62
%81 = fptrunc double %80 to float
%82 = getelementptr inbounds double, double* %1, i64 %77
%83 = load double, double* %82
%84 = fsub double %83, %64
%85 = fptrunc double %84 to float
%86 = fdiv double %76, %43
%87 = fptrunc double %86 to float
%88 = fdiv float %81, %20
%89 = fdiv double %75, %43
%90 = fmul float %87, %87
%91 = fpext float %90 to double
%92 = fsub double %89, %91
%93 = fdiv float %85, %20
%94 = fpext float %93 to double
%95 = fadd double %92, %94
%96 = fmul float %88, %88
%97 = fpext float %96 to double
%98 = fsub double %95, %97
%99 = fptrunc double %98 to float
%100 = tail call float @llvm.maxnum.f32(float %99, float %19)
%101 = fsub float %88, %87
%102 = tail call float @llvm.fabs.f32(float %101)
%103 = fdiv float %100, %20
%104 = tail call float @sqrt(float %103)
%105 = fdiv float %102, %104
%106 = getelementptr inbounds float, float* %15, i64 %60
store float %105, float* %106
%107 = add i64 %60, 1
%108 = icmp ugt i64 %107, %40
br i1 %108, label %109, label %59
109: ; preds = %74, %30, %39, %28, %14, %4
%110 = phi float* [ null, %4 ], [ null, %14 ], [ %15, %28 ], [ %15, %39 ], [ %15, %30 ], [ %15, %74 ]
ret float* %110
}