#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 */
typedef scalar_t__ int64_t;

/* Variables and functions */
int /*<<< orphan*/ snansumpw(scalar_t__ const, double *, float const *,
                             scalar_t__ const);
float stdlib_strided_snanvariancepn(const int64_t N, const float correction,
                                    const float *X, const int64_t stride) {
  double W[] = {0.0, 0.0};
  int64_t ix;
  int64_t i;
  double nc;
  double dM;
  double n;
  float M2;
  float mu;
  float M;
  float d;
  float v;
  if (N <= 0) {
    return 0.0f / 0.0f;
  }
  if (N == 1 || stride == 0) {
    v = X[0];
    if (v == v && (double)N - (double)correction > 0.0) {
      return 0.0f;
    }
    return 0.0f / 0.0f;
  }
  snansumpw(N, W, X, stride);
  n = W[1];
  nc = n - (double)correction;
  if (nc <= 0.0) {
    return 0.0f / 0.0f;
  }
  if (stride < 0) {
    ix = (1 - N) * stride;
  } else {
    ix = 0;
  }
  mu = (float)(W[0] / n);
  M2 = 0.0f;
  M = 0.0f;
  for (i = 0; i < N; i++) {
    v = X[ix];
    if (v == v) {
      d = v - mu;
      M2 += d * d;
      M += d;
      n += 1;
    }
    ix += stride;
  }
  dM = (double)M;
  return (float)((double)M2 / nc) - ((float)(dM / n) * (float)(dM / nc));
}


x86 assembly (clang, -O0):
<stdlib_strided_snanvariancepn>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
lea    -0x40(%rbp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1040 <memset@plt>
cmpq   $0x0,-0x10(%rbp)
jg     1169 <stdlib_strided_snanvariancepn+0x49>
movss  0xea9(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    137f <stdlib_strided_snanvariancepn+0x25f>
cmpq   $0x1,-0x10(%rbp)
je     117f <stdlib_strided_snanvariancepn+0x5f>
cmpq   $0x0,-0x28(%rbp)
jne    11e0 <stdlib_strided_snanvariancepn+0xc0>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
ucomiss -0x7c(%rbp),%xmm0
jne    11ce <stdlib_strided_snanvariancepn+0xae>
jp     11ce <stdlib_strided_snanvariancepn+0xae>
cvtsi2sdq -0x10(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    11ce <stdlib_strided_snanvariancepn+0xae>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    137f <stdlib_strided_snanvariancepn+0x25f>
movss  0xe32(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    137f <stdlib_strided_snanvariancepn+0x25f>
mov    -0x10(%rbp),%rdi
lea    -0x40(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
call   1030 <snansumpw@plt>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x58(%rbp),%xmm0
jb     1236 <stdlib_strided_snanvariancepn+0x116>
movss  0xddc(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    137f <stdlib_strided_snanvariancepn+0x25f>
cmpq   $0x0,-0x28(%rbp)
jge    1258 <stdlib_strided_snanvariancepn+0x138>
mov    $0x1,%eax
sub    -0x10(%rbp),%rax
imul   -0x28(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    1260 <stdlib_strided_snanvariancepn+0x140>
movq   $0x0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1329 <stdlib_strided_snanvariancepn+0x209>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
ucomiss -0x7c(%rbp),%xmm0
jne    130c <stdlib_strided_snanvariancepn+0x1ec>
jp     130c <stdlib_strided_snanvariancepn+0x1ec>
movss  -0x7c(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movsd  0xcfe(%rip),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    128b <stdlib_strided_snanvariancepn+0x16b>
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  -0x58(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  -0x60(%rbp),%xmm2
divsd  -0x58(%rbp),%xmm2
cvtsd2ss %xmm2,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stdlib_strided_snanvariancepn>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
xorpd  %xmm1,%xmm1
movapd %xmm1,0x10(%rsp)
movss  0xed5(%rip),%xmm3
test   %rdi,%rdi
jle    11f4 <stdlib_strided_snanvariancepn+0xe4>
mov    %rsi,%r15
mov    %rdi,%r14
cmp    $0x1,%rdi
je     11c9 <stdlib_strided_snanvariancepn+0xb9>
mov    %rdx,%rbx
test   %rdx,%rdx
je     11c9 <stdlib_strided_snanvariancepn+0xb9>
lea    0x10(%rsp),%rsi
mov    %r14,%rdi
mov    %r15,%rdx
mov    %rbx,%rcx
movss  %xmm0,0xc(%rsp)
call   1030 <snansumpw@plt>
movsd  0x18(%rsp),%xmm2
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movapd %xmm2,%xmm1
subsd  %xmm0,%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
movss  0xe73(%rip),%xmm0
jae    12c9 <stdlib_strided_snanvariancepn+0x1b9>
lea    -0x1(%r14),%rcx
neg    %rcx
imul   %rbx,%rcx
mov    %rbx,%rax
sar    $0x3f,%rax
and    %rcx,%rax
mov    %r14,%rcx
movsd  0x10(%rsp),%xmm0
divsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm4
dec    %rcx
jne    11fc <stdlib_strided_snanvariancepn+0xec>
xorps  %xmm0,%xmm0
xorps  %xmm3,%xmm3
jmp    1269 <stdlib_strided_snanvariancepn+0x159>
movss  (%r15),%xmm1
ucomiss %xmm1,%xmm1
jp     11f4 <stdlib_strided_snanvariancepn+0xe4>
xorps  %xmm1,%xmm1
cvtsi2sd %r14,%xmm1
cvtss2sd %xmm0,%xmm0
subsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm1
ja     12c9 <stdlib_strided_snanvariancepn+0x1b9>
movaps %xmm3,%xmm0
jmp    12c9 <stdlib_strided_snanvariancepn+0x1b9>
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%r15,%rbx,4),%rdx
xorps  %xmm0,%xmm0
movsd  0xdf6(%rip),%xmm5
xorps  %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r15,%rax,4),%xmm6
ucomiss %xmm6,%xmm6
jp     123f <stdlib_strided_snanvariancepn+0x12f>
subss  %xmm4,%xmm6
addss  %xmm6,%xmm0
mulss  %xmm6,%xmm6
addss  %xmm6,%xmm3
addsd  %xmm5,%xmm2
movss  (%rdx,%rax,4),%xmm6
add    %rbx,%rax
ucomiss %xmm6,%xmm6
jp     1260 <stdlib_strided_snanvariancepn+0x150>
subss  %xmm4,%xmm6
addss  %xmm6,%xmm0
mulss  %xmm6,%xmm6
addss  %xmm6,%xmm3
addsd  %xmm5,%xmm2
add    %rbx,%rax
add    $0xfffffffffffffffe,%rcx
jne    1220 <stdlib_strided_snanvariancepn+0x110>
test   $0x1,%r14b
je     1292 <stdlib_strided_snanvariancepn+0x182>
movss  (%r15,%rax,4),%xmm5
ucomiss %xmm5,%xmm5
jp     1292 <stdlib_strided_snanvariancepn+0x182>
subss  %xmm4,%xmm5
addss  %xmm5,%xmm0
mulss  %xmm5,%xmm5
addss  %xmm5,%xmm3
addsd  0xd76(%rip),%xmm2
xorps  %xmm4,%xmm4
cvtss2sd %xmm0,%xmm4
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movaps %xmm4,%xmm3
divsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
divsd  %xmm1,%xmm4
xorps  %xmm1,%xmm1
cvtsd2ss %xmm4,%xmm1
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm0
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define float @stdlib_strided_snanvariancepn(i64 %0, float %1, float* %2, i64 %3) {
%5 = alloca float
%6 = alloca i64
%7 = alloca float
%8 = alloca float*
%9 = alloca i64
%10 = alloca [2 x double]
%11 = alloca i64
%12 = alloca i64
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
store i64 %0, i64* %6
store float %1, float* %7
store float* %2, float** %8
store i64 %3, i64* %9
%21 = bitcast [2 x double]* %10 to i8*
%22 = load i64, i64* %6
%23 = icmp sle i64 %22, 0
br i1 %23, label %24, label %25
24: ; preds = %4
store float 0x7FF8000000000000, float* %5
br label %127
25: ; preds = %4
%26 = load i64, i64* %6
%27 = icmp eq i64 %26, 1
br i1 %27, label %31, label %28
28: ; preds = %25
%29 = load i64, i64* %9
%30 = icmp eq i64 %29, 0
br i1 %30, label %31, label %47
31: ; preds = %28, %25
%32 = load float*, float** %8
%33 = getelementptr inbounds float, float* %32, i64 0
%34 = load float, float* %33
store float %34, float* %20
%35 = load float, float* %20
%36 = load float, float* %20
%37 = fcmp oeq float %35, %36
br i1 %37, label %38, label %46
38: ; preds = %31
%39 = load i64, i64* %6
%40 = sitofp i64 %39 to double
%41 = load float, float* %7
%42 = fpext float %41 to double
%43 = fsub double %40, %42
%44 = fcmp ogt double %43, 0.000000e+00
br i1 %44, label %45, label %46
45: ; preds = %38
store float 0.000000e+00, float* %5
br label %127
46: ; preds = %38, %31
store float 0x7FF8000000000000, float* %5
br label %127
47: ; preds = %28
%48 = load i64, i64* %6
%49 = getelementptr inbounds [2 x double], [2 x double]* %10, i64 0, i64 0
%50 = load float*, float** %8
%51 = load i64, i64* %9
%52 = call i32 @snansumpw(i64 %48, double* %49, float* %50, i64 %51)
%53 = getelementptr inbounds [2 x double], [2 x double]* %10, i64 0, i64 1
%54 = load double, double* %53
store double %54, double* %15
%55 = load double, double* %15
%56 = load float, float* %7
%57 = fpext float %56 to double
%58 = fsub double %55, %57
store double %58, double* %13
%59 = load double, double* %13
%60 = fcmp ole double %59, 0.000000e+00
br i1 %60, label %61, label %62
61: ; preds = %47
store float 0x7FF8000000000000, float* %5
br label %127
62: ; preds = %47
%63 = load i64, i64* %9
%64 = icmp slt i64 %63, 0
br i1 %64, label %65, label %70
65: ; preds = %62
%66 = load i64, i64* %6
%67 = sub nsw i64 1, %66
%68 = load i64, i64* %9
%69 = mul nsw i64 %67, %68
store i64 %69, i64* %11
br label %71
70: ; preds = %62
store i64 0, i64* %11
br label %71
71: ; preds = %70, %65
%72 = getelementptr inbounds [2 x double], [2 x double]* %10, i64 0, i64 0
%73 = load double, double* %72
%74 = load double, double* %15
%75 = fdiv double %73, %74
%76 = fptrunc double %75 to float
store float %76, float* %17
store float 0.000000e+00, float* %16
store float 0.000000e+00, float* %18
store i64 0, i64* %12
br label %77
77: ; preds = %106, %71
%78 = load i64, i64* %12
%79 = load i64, i64* %6
%80 = icmp slt i64 %78, %79
br i1 %80, label %81, label %109
81: ; preds = %77
%82 = load float*, float** %8
%83 = load i64, i64* %11
%84 = getelementptr inbounds float, float* %82, i64 %83
%85 = load float, float* %84
store float %85, float* %20
%86 = load float, float* %20
%87 = load float, float* %20
%88 = fcmp oeq float %86, %87
br i1 %88, label %89, label %102
89: ; preds = %81
%90 = load float, float* %20
%91 = load float, float* %17
%92 = fsub float %90, %91
store float %92, float* %19
%93 = load float, float* %19
%94 = load float, float* %19
%95 = load float, float* %16
%96 = call float @llvm.fmuladd.f32(float %93, float %94, float %95)
store float %96, float* %16
%97 = load float, float* %19
%98 = load float, float* %18
%99 = fadd float %98, %97
store float %99, float* %18
%100 = load double, double* %15
%101 = fadd double %100, 1.000000e+00
store double %101, double* %15
br label %102
102: ; preds = %89, %81
%103 = load i64, i64* %9
%104 = load i64, i64* %11
%105 = add nsw i64 %104, %103
store i64 %105, i64* %11
br label %106
106: ; preds = %102
%107 = load i64, i64* %12
%108 = add nsw i64 %107, 1
store i64 %108, i64* %12
br label %77
109: ; preds = %77
%110 = load float, float* %18
%111 = fpext float %110 to double
store double %111, double* %14
%112 = load float, float* %16
%113 = fpext float %112 to double
%114 = load double, double* %13
%115 = fdiv double %113, %114
%116 = fptrunc double %115 to float
%117 = load double, double* %14
%118 = load double, double* %15
%119 = fdiv double %117, %118
%120 = fptrunc double %119 to float
%121 = load double, double* %14
%122 = load double, double* %13
%123 = fdiv double %121, %122
%124 = fptrunc double %123 to float
%125 = fneg float %120
%126 = call float @llvm.fmuladd.f32(float %125, float %124, float %116)
store float %126, float* %5
br label %127
127: ; preds = %109, %61, %46, %45, %24
%128 = load float, float* %5
ret float %128
}

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