#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*/ printf(char *, int, float, float, ...);
float sqrtf(float);
void array_mean_var_cut(float *__restrict img, int npx, float *mean, float *std,
                        int n, float cut, int verbose) {
  int i, nactive;
  float t, s1, s2, wt, y0;
  y0 = img[0];
  s1 = 0;
  s2 = 0;
  if (verbose)
    printf("Args, img[0] %f npx %d n %d cut %f verbose %d\n", img[0], npx, n,
           cut, verbose);
#pragma omp parallel for private(t) reduction(+ : s1, s2)
  for (i = 0; i < npx; i++) {
    t = img[i] - y0;
    s1 = s1 + t;
    s2 = s2 + t * t;
  }
  *mean = (float)(s1 / npx + y0);
  *std = sqrtf((float)((s2 - (s1 * s1 / npx)) / npx));
  if (verbose > 0)
    printf("n=%d Mean %f, Std %f\n", n, *mean, *std);
  while (--n > 0) {
    y0 = *mean;
    wt = y0 + cut * (*std);
    s1 = 0;
    s2 = 0;
    nactive = 0;
#pragma omp parallel for private(t) reduction(+ : s1, s2, nactive)
    for (i = 0; i < npx; i++) {
      if (img[i] < wt) {
        t = img[i] - y0;
        s1 = s1 + t;
        s2 = s2 + t * t;
        nactive++;
      }
    }
    *mean = (float)(s1 / nactive + *mean);
    *std = sqrtf(((s2 - (s1 * s1 / nactive)) / nactive));
    if (verbose > 0)
      printf("n=%d Mean %f, Std %f\n", n, *mean, *std);
  }
}


x86 assembly (clang, -O0):
<array_mean_var_cut>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movss  %xmm0,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1197 <array_mean_var_cut+0x77>
mov    -0x8(%rbp),%rax
cvttss2si (%rax),%esi
cvtsi2ssl -0xc(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mov    -0x2c(%rbp),%edx
lea    0xe70(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11fa <array_mean_var_cut+0xda>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    119e <array_mean_var_cut+0x7e>
movss  -0x3c(%rbp),%xmm0
cvtsi2ssl -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
addss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x40(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
cvtsi2ssl -0xc(%rbp),%xmm2
divss  %xmm2,%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
call   1040 <sqrtf@plt>
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
cmpl   $0x0,-0x2c(%rbp)
jle    1272 <array_mean_var_cut+0x152>
mov    -0x24(%rbp),%esi
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
lea    0xdc4(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
jmp    1277 <array_mean_var_cut+0x157>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
jle    13d8 <array_mean_var_cut+0x2b8>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x28(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1358 <array_mean_var_cut+0x238>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x44(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1345 <array_mean_var_cut+0x225>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    134a <array_mean_var_cut+0x22a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12d3 <array_mean_var_cut+0x1b3>
movss  -0x3c(%rbp),%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
addss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x40(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
cvtsi2ssl -0x34(%rbp),%xmm2
divss  %xmm2,%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
divss  %xmm1,%xmm0
call   1040 <sqrtf@plt>
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
cmpl   $0x0,-0x2c(%rbp)
jle    13d3 <array_mean_var_cut+0x2b3>
mov    -0x24(%rbp),%esi
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
lea    0xc63(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
jmp    1277 <array_mean_var_cut+0x157>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<array_mean_var_cut>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9d,%r14d
mov    %r8d,%ebp
mov    %rcx,0x18(%rsp)
mov    %rdx,%r13
mov    %esi,%r12d
mov    %rdi,%rbx
movss  (%rdi),%xmm5
test   %r9d,%r9d
movss  %xmm0,0x24(%rsp)
je     1185 <array_mean_var_cut+0x65>
movaps %xmm0,%xmm2
cvttss2si %xmm5,%esi
xorps  %xmm0,%xmm0
cvtsi2ss %r12d,%xmm0
cvtsi2ss %ebp,%xmm1
cvtss2sd %xmm2,%xmm2
lea    0xe95(%rip),%rdi
mov    %r14d,%edx
mov    $0x3,%al
movss  %xmm5,0xc(%rsp)
call   1030 <printf@plt>
movss  0xc(%rsp),%xmm5
xorps  %xmm1,%xmm1
mov    %r12d,%eax
mov    %rax,0x10(%rsp)
xorps  %xmm2,%xmm2
xorps  %xmm0,%xmm0
test   %r12d,%r12d
jle    127e <array_mean_var_cut+0x15e>
movaps %xmm5,%xmm0
subss  %xmm5,%xmm0
xorps  %xmm3,%xmm3
movaps %xmm0,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm3,%xmm0
cmp    $0x1,%r12d
je     127e <array_mean_var_cut+0x15e>
mov    0x10(%rsp),%rax
lea    -0x1(%rax),%rdx
lea    -0x2(%rax),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    11e9 <array_mean_var_cut+0xc9>
mov    $0x1,%ecx
test   %rax,%rax
jne    125a <array_mean_var_cut+0x13a>
jmp    127e <array_mean_var_cut+0x15e>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
nop
movss  0x4(%rbx,%rcx,4),%xmm3
movss  0x8(%rbx,%rcx,4),%xmm4
subss  %xmm5,%xmm3
addss  %xmm3,%xmm2
mulss  %xmm3,%xmm3
addss  %xmm0,%xmm3
subss  %xmm5,%xmm4
addss  %xmm4,%xmm2
mulss  %xmm4,%xmm4
addss  %xmm3,%xmm4
movss  0xc(%rbx,%rcx,4),%xmm3
subss  %xmm5,%xmm3
addss  %xmm3,%xmm2
mulss  %xmm3,%xmm3
addss  %xmm4,%xmm3
movss  0x10(%rbx,%rcx,4),%xmm0
subss  %xmm5,%xmm0
addss  %xmm0,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm3,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    11f0 <array_mean_var_cut+0xd0>
add    $0x1,%rcx
test   %rax,%rax
je     127e <array_mean_var_cut+0x15e>
lea    (%rbx,%rcx,4),%rcx
xor    %edx,%edx
movss  (%rcx,%rdx,4),%xmm3
subss  %xmm5,%xmm3
addss  %xmm3,%xmm2
mulss  %xmm3,%xmm3
addss  %xmm3,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1260 <array_mean_var_cut+0x140>
xorps  %xmm3,%xmm3
cvtsi2ss %r12d,%xmm3
movaps %xmm2,%xmm4
divss  %xmm3,%xmm4
addss  %xmm4,%xmm5
movss  %xmm5,0x0(%r13)
mulss  %xmm2,%xmm2
divss  %xmm3,%xmm2
subss  %xmm2,%xmm0
divss  %xmm3,%xmm0
ucomiss %xmm1,%xmm0
jb     12b5 <array_mean_var_cut+0x195>
xorps  %xmm1,%xmm1
sqrtss %xmm0,%xmm1
jmp    12bd <array_mean_var_cut+0x19d>
call   1040 <sqrtf@plt>
movaps %xmm0,%xmm1
mov    0x18(%rsp),%rax
movss  %xmm1,(%rax)
mov    %r14d,0xc(%rsp)
test   %r14d,%r14d
jle    12e6 <array_mean_var_cut+0x1c6>
movss  0x0(%r13),%xmm0
lea    0xd56(%rip),%rdi
mov    %ebp,%esi
mov    $0x2,%al
call   1030 <printf@plt>
cmp    $0x2,%ebp
jl     144c <array_mean_var_cut+0x32c>
mov    0x10(%rsp),%r15
and    $0xfffffffe,%r15d
jmp    130c <array_mean_var_cut+0x1ec>
nopw   0x0(%rax,%rax,1)
cmp    $0x2,%ebp
mov    %r14d,%ebp
jle    144c <array_mean_var_cut+0x32c>
movss  0x0(%r13),%xmm1
test   %r12d,%r12d
jle    13c0 <array_mean_var_cut+0x2a0>
mov    0x18(%rsp),%rax
movss  (%rax),%xmm3
mulss  0x24(%rsp),%xmm3
addss  %xmm1,%xmm3
xor    %ecx,%ecx
xorps  %xmm0,%xmm0
xorps  %xmm2,%xmm2
xor    %eax,%eax
cmp    $0x1,%r12d
jne    1379 <array_mean_var_cut+0x259>
testb  $0x1,0x10(%rsp)
je     13c8 <array_mean_var_cut+0x2a8>
movss  (%rbx,%rcx,4),%xmm4
ucomiss %xmm4,%xmm3
jbe    13c8 <array_mean_var_cut+0x2a8>
subss  %xmm1,%xmm4
addss  %xmm4,%xmm2
mulss  %xmm4,%xmm4
addss  %xmm4,%xmm0
add    $0x1,%eax
jmp    13c8 <array_mean_var_cut+0x2a8>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rcx
cmp    %rcx,%r15
je     133e <array_mean_var_cut+0x21e>
movss  (%rbx,%rcx,4),%xmm4
ucomiss %xmm4,%xmm3
jbe    1396 <array_mean_var_cut+0x276>
subss  %xmm1,%xmm4
addss  %xmm4,%xmm2
mulss  %xmm4,%xmm4
addss  %xmm4,%xmm0
add    $0x1,%eax
movss  0x4(%rbx,%rcx,4),%xmm4
ucomiss %xmm4,%xmm3
jbe    1370 <array_mean_var_cut+0x250>
subss  %xmm1,%xmm4
addss  %xmm4,%xmm2
mulss  %xmm4,%xmm4
addss  %xmm4,%xmm0
add    $0x1,%eax
jmp    1370 <array_mean_var_cut+0x250>
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
xorps  %xmm2,%xmm2
xorps  %xmm0,%xmm0
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
movaps %xmm2,%xmm4
divss  %xmm3,%xmm4
addss  %xmm4,%xmm1
movss  %xmm1,0x0(%r13)
mulss  %xmm2,%xmm2
divss  %xmm3,%xmm2
subss  %xmm2,%xmm0
divss  %xmm3,%xmm0
ucomiss 0xc09(%rip),%xmm0
jb     1410 <array_mean_var_cut+0x2f0>
xorps  %xmm1,%xmm1
sqrtss %xmm0,%xmm1
jmp    1418 <array_mean_var_cut+0x2f8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
call   1040 <sqrtf@plt>
movaps %xmm0,%xmm1
lea    -0x1(%rbp),%r14d
mov    0x18(%rsp),%rax
movss  %xmm1,(%rax)
cmpl   $0x0,0xc(%rsp)
jle    1300 <array_mean_var_cut+0x1e0>
movss  0x0(%r13),%xmm0
lea    0xbf6(%rip),%rdi
mov    %r14d,%esi
mov    $0x2,%al
call   1030 <printf@plt>
jmp    1300 <array_mean_var_cut+0x1e0>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [47 x i8] c"Args, img[0] %f npx %d n %d cut %f verbose %d\0A\00"
@.str.1 = [22 x i8] c"n=%d Mean %f, Std %f\0A\00"
define void @array_mean_var_cut(float* noalias %0, i32 %1, float* %2, float* %3, i32 %4, float %5, i32 %6) {
%8 = alloca float*
%9 = alloca i32
%10 = alloca float*
%11 = alloca float*
%12 = alloca i32
%13 = alloca float
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
store float* %0, float** %8
store i32 %1, i32* %9
store float* %2, float** %10
store float* %3, float** %11
store i32 %4, i32* %12
store float %5, float* %13
store i32 %6, i32* %14
%22 = load float*, float** %8
%23 = getelementptr inbounds float, float* %22, i64 0
%24 = load float, float* %23
store float %24, float* %21
store float 0.000000e+00, float* %18
store float 0.000000e+00, float* %19
%25 = load i32, i32* %14
%26 = icmp ne i32 %25, 0
br i1 %26, label %27, label %40
27: ; preds = %7
%28 = load float*, float** %8
%29 = getelementptr inbounds float, float* %28, i64 0
%30 = load float, float* %29
%31 = fptosi float %30 to i32
%32 = load i32, i32* %9
%33 = sitofp i32 %32 to float
%34 = load i32, i32* %12
%35 = sitofp i32 %34 to float
%36 = load float, float* %13
%37 = fpext float %36 to double
%38 = load i32, i32* %14
%39 = call i32 (i8*, i32, float, float, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str, i64 0, i64 0), i32 %31, float %33, float %35, double %37, i32 %38)
br label %40
40: ; preds = %27, %7
store i32 0, i32* %15
br label %41
41: ; preds = %60, %40
%42 = load i32, i32* %15
%43 = load i32, i32* %9
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %63
45: ; preds = %41
%46 = load float*, float** %8
%47 = load i32, i32* %15
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds float, float* %46, i64 %48
%50 = load float, float* %49
%51 = load float, float* %21
%52 = fsub float %50, %51
store float %52, float* %17
%53 = load float, float* %18
%54 = load float, float* %17
%55 = fadd float %53, %54
store float %55, float* %18
%56 = load float, float* %19
%57 = load float, float* %17
%58 = load float, float* %17
%59 = call float @llvm.fmuladd.f32(float %57, float %58, float %56)
store float %59, float* %19
br label %60
60: ; preds = %45
%61 = load i32, i32* %15
%62 = add nsw i32 %61, 1
store i32 %62, i32* %15
br label %41
63: ; preds = %41
%64 = load float, float* %18
%65 = load i32, i32* %9
%66 = sitofp i32 %65 to float
%67 = fdiv float %64, %66
%68 = load float, float* %21
%69 = fadd float %67, %68
%70 = load float*, float** %10
store float %69, float* %70
%71 = load float, float* %19
%72 = load float, float* %18
%73 = load float, float* %18
%74 = fmul float %72, %73
%75 = load i32, i32* %9
%76 = sitofp i32 %75 to float
%77 = fdiv float %74, %76
%78 = fsub float %71, %77
%79 = load i32, i32* %9
%80 = sitofp i32 %79 to float
%81 = fdiv float %78, %80
%82 = call float @sqrtf(float %81)
%83 = load float*, float** %11
store float %82, float* %83
%84 = load i32, i32* %14
%85 = icmp sgt i32 %84, 0
br i1 %85, label %86, label %93
86: ; preds = %63
%87 = load i32, i32* %12
%88 = load float*, float** %10
%89 = load float, float* %88
%90 = load float*, float** %11
%91 = load float, float* %90
%92 = call i32 (i8*, i32, float, float, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.1, i64 0, i64 0), i32 %87, float %89, float %91)
br label %93
93: ; preds = %86, %63
br label %94
94: ; preds = %170, %93
%95 = load i32, i32* %12
%96 = add nsw i32 %95, -1
store i32 %96, i32* %12
%97 = icmp sgt i32 %96, 0
br i1 %97, label %98, label %171
98: ; preds = %94
%99 = load float*, float** %10
%100 = load float, float* %99
store float %100, float* %21
%101 = load float, float* %21
%102 = load float, float* %13
%103 = load float*, float** %11
%104 = load float, float* %103
%105 = call float @llvm.fmuladd.f32(float %102, float %104, float %101)
store float %105, float* %20
store float 0.000000e+00, float* %18
store float 0.000000e+00, float* %19
store i32 0, i32* %16
store i32 0, i32* %15
br label %106
106: ; preds = %136, %98
%107 = load i32, i32* %15
%108 = load i32, i32* %9
%109 = icmp slt i32 %107, %108
br i1 %109, label %110, label %139
110: ; preds = %106
%111 = load float*, float** %8
%112 = load i32, i32* %15
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %111, i64 %113
%115 = load float, float* %114
%116 = load float, float* %20
%117 = fcmp olt float %115, %116
br i1 %117, label %118, label %135
118: ; preds = %110
%119 = load float*, float** %8
%120 = load i32, i32* %15
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds float, float* %119, i64 %121
%123 = load float, float* %122
%124 = load float, float* %21
%125 = fsub float %123, %124
store float %125, float* %17
%126 = load float, float* %18
%127 = load float, float* %17
%128 = fadd float %126, %127
store float %128, float* %18
%129 = load float, float* %19
%130 = load float, float* %17
%131 = load float, float* %17
%132 = call float @llvm.fmuladd.f32(float %130, float %131, float %129)
store float %132, float* %19
%133 = load i32, i32* %16
%134 = add nsw i32 %133, 1
store i32 %134, i32* %16
br label %135
135: ; preds = %118, %110
br label %136
136: ; preds = %135
%137 = load i32, i32* %15
%138 = add nsw i32 %137, 1
store i32 %138, i32* %15
br label %106
139: ; preds = %106
%140 = load float, float* %18
%141 = load i32, i32* %16
%142 = sitofp i32 %141 to float
%143 = fdiv float %140, %142
%144 = load float*, float** %10
%145 = load float, float* %144
%146 = fadd float %143, %145
%147 = load float*, float** %10
store float %146, float* %147
%148 = load float, float* %19
%149 = load float, float* %18
%150 = load float, float* %18
%151 = fmul float %149, %150
%152 = load i32, i32* %16
%153 = sitofp i32 %152 to float
%154 = fdiv float %151, %153
%155 = fsub float %148, %154
%156 = load i32, i32* %16
%157 = sitofp i32 %156 to float
%158 = fdiv float %155, %157
%159 = call float @sqrtf(float %158)
%160 = load float*, float** %11
store float %159, float* %160
%161 = load i32, i32* %14
%162 = icmp sgt i32 %161, 0
br i1 %162, label %163, label %170
163: ; preds = %139
%164 = load i32, i32* %12
%165 = load float*, float** %10
%166 = load float, float* %165
%167 = load float*, float** %11
%168 = load float, float* %167
%169 = call i32 (i8*, i32, float, float, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.1, i64 0, i64 0), i32 %164, float %166, float %168)
br label %170
170: ; preds = %163, %139
br label %94
171: ; preds = %94
ret void
}

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