#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 */
int /*<<< orphan*/ assert(int);
float snrVariance(float s[], float n[], int blksz) {
  int i;
  double sm = 0, nm = 0, sv = 0, nv = 0, snr;
  for (i = 0; i < blksz; i++) {
    sm += s[i];
    nm += n[i];
  }
  sm /= blksz;
  nm /= blksz;
  for (i = 0; i < blksz; i++) {
    sv += (s[i] - sm) * (s[i] - sm);
    nv += (n[i] - nm) * (n[i] - nm);
  }
  if (nv != 0.0f) {
    assert(sv >= nv);
    snr = sv / nv;
    return snr;
  } else {
    return 9999.9f;
  }
}


x86 assembly (clang, -O0):
<snrVariance>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    119a <snrVariance+0x8a>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    114a <snrVariance+0x3a>
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    125d <snrVariance+0x14d>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
subsd  -0x28(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
subsd  -0x30(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11c7 <snrVariance+0xb7>
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    127a <snrVariance+0x16a>
jp     127a <snrVariance+0x16a>
jmp    12b3 <snrVariance+0x1a3>
movsd  -0x38(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movsd  -0x38(%rbp),%xmm0
divsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    12c0 <snrVariance+0x1b0>
movss  0xd45(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<snrVariance>:
sub    $0x28,%rsp
movss  0xee4(%rip),%xmm0
test   %edx,%edx
jle    1262 <snrVariance+0x152>
mov    %edx,%r8d
mov    %r8,%r9
add    $0xffffffffffffffff,%r9
je     1267 <snrVariance+0x157>
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
xorpd  %xmm1,%xmm1
xor    %eax,%eax
movss  (%rdi,%rax,4),%xmm2
movss  0x4(%rdi,%rax,4),%xmm3
movss  (%rsi,%rax,4),%xmm4
unpcklps %xmm2,%xmm4
movss  0x4(%rsi,%rax,4),%xmm2
cvtps2pd %xmm4,%xmm4
unpcklps %xmm3,%xmm2
addpd  %xmm1,%xmm4
cvtps2pd %xmm2,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rax
cmp    %rax,%rcx
jne    1140 <snrVariance+0x30>
test   $0x1,%r8b
je     118d <snrVariance+0x7d>
movss  (%rdi,%rax,4),%xmm2
movss  (%rsi,%rax,4),%xmm3
unpcklps %xmm2,%xmm3
cvtps2pd %xmm3,%xmm2
addpd  %xmm2,%xmm1
test   %edx,%edx
jle    1262 <snrVariance+0x152>
xorps  %xmm2,%xmm2
cvtsi2sd %edx,%xmm2
unpcklpd %xmm2,%xmm2
divpd  %xmm2,%xmm1
test   %r9,%r9
je     127c <snrVariance+0x16c>
mov    %r8d,%eax
and    $0xfffffffe,%eax
xorpd  %xmm5,%xmm5
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rdi,%rcx,4),%xmm2
movss  0x4(%rdi,%rcx,4),%xmm3
movss  (%rsi,%rcx,4),%xmm4
unpcklps %xmm2,%xmm4
movss  0x4(%rsi,%rcx,4),%xmm2
unpcklps %xmm3,%xmm2
cvtps2pd %xmm4,%xmm3
subpd  %xmm1,%xmm3
mulpd  %xmm3,%xmm3
addpd  %xmm5,%xmm3
cvtps2pd %xmm2,%xmm5
subpd  %xmm1,%xmm5
mulpd  %xmm5,%xmm5
addpd  %xmm3,%xmm5
add    $0x2,%rcx
cmp    %rcx,%rax
jne    11c0 <snrVariance+0xb0>
test   $0x1,%r8b
je     1225 <snrVariance+0x115>
movss  (%rdi,%rcx,4),%xmm2
movss  (%rsi,%rcx,4),%xmm3
unpcklps %xmm2,%xmm3
cvtps2pd %xmm3,%xmm2
subpd  %xmm1,%xmm2
mulpd  %xmm2,%xmm2
addpd  %xmm2,%xmm5
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm5
jne    1231 <snrVariance+0x121>
jnp    1262 <snrVariance+0x152>
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
movapd %xmm0,0x10(%rsp)
xor    %edi,%edi
ucomisd %xmm5,%xmm0
setae  %dil
movapd %xmm5,(%rsp)
call   1030 <assert@plt>
movapd 0x10(%rsp),%xmm0
divsd  (%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
add    $0x28,%rsp
ret
xor    %eax,%eax
xorpd  %xmm1,%xmm1
test   $0x1,%r8b
jne    1179 <snrVariance+0x69>
jmp    118d <snrVariance+0x7d>
xorpd  %xmm5,%xmm5
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1209 <snrVariance+0xf9>
jmp    1225 <snrVariance+0x115>

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

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