#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 mean_DWTAnlz(float *, int, int /*<<< orphan*/ *);
float stddev_DWTAnlz(float *, int, int /*<<< orphan*/ *);
void denoise_DWTAnlz(float *ip, float *op, int n, float k) {
  float trshldlo = mean_DWTAnlz(ip, n, NULL) - k * stddev_DWTAnlz(ip, n, NULL);
  float trshldhi = mean_DWTAnlz(ip, n, NULL) + k * stddev_DWTAnlz(ip, n, NULL);
  for (int i = 1; i < n; i++) {
    if (ip[i] > trshldhi || ip[i] < trshldlo)
      op[i] = ip[i];
    else
      op[i] = 0;
  }
}


x86 assembly (clang, -O0):
<denoise_DWTAnlz>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
xor    %eax,%eax
mov    %eax,%edx
call   1040 <mean_DWTAnlz@plt>
movss  %xmm0,-0x34(%rbp)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
xor    %eax,%eax
mov    %eax,%edx
call   1030 <stddev_DWTAnlz@plt>
movss  -0x34(%rbp),%xmm1
movaps %xmm0,%xmm2
movss  -0x30(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
xor    %eax,%eax
mov    %eax,%edx
call   1040 <mean_DWTAnlz@plt>
movss  %xmm0,-0x2c(%rbp)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
xor    %eax,%eax
mov    %eax,%edx
call   1030 <stddev_DWTAnlz@plt>
movss  -0x2c(%rbp),%xmm1
movaps %xmm0,%xmm2
movss  -0x28(%rbp),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    125e <denoise_DWTAnlz+0x13e>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x20(%rbp),%xmm0
ja     121c <denoise_DWTAnlz+0xfc>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    123b <denoise_DWTAnlz+0x11b>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    124b <denoise_DWTAnlz+0x12b>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1250 <denoise_DWTAnlz+0x130>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11de <denoise_DWTAnlz+0xbe>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<denoise_DWTAnlz>:
push   %rbp
push   %r14
push   %rbx
sub    $0x20,%rsp
movss  %xmm0,0xc(%rsp)
mov    %edx,%ebp
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %edx,%esi
xor    %edx,%edx
call   1040 <mean_DWTAnlz@plt>
movaps %xmm0,0x10(%rsp)
mov    %rbx,%rdi
mov    %ebp,%esi
xor    %edx,%edx
call   1030 <stddev_DWTAnlz@plt>
movss  %xmm0,0x8(%rsp)
mov    %rbx,%rdi
mov    %ebp,%esi
xor    %edx,%edx
call   1040 <mean_DWTAnlz@plt>
movss  %xmm0,0x4(%rsp)
mov    %rbx,%rdi
mov    %ebp,%esi
xor    %edx,%edx
call   1030 <stddev_DWTAnlz@plt>
movaps 0x10(%rsp),%xmm8
cmp    $0x2,%ebp
jl     12e1 <denoise_DWTAnlz+0x1c1>
movss  0xc(%rsp),%xmm1
movss  0x8(%rsp),%xmm2
mulss  %xmm1,%xmm2
subss  %xmm2,%xmm8
mulss  %xmm1,%xmm0
addss  0x4(%rsp),%xmm0
mov    %ebp,%eax
lea    -0x1(%rax),%rdx
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     1240 <denoise_DWTAnlz+0x120>
lea    0x4(%r14),%rsi
lea    (%rbx,%rax,4),%rdi
cmp    %rdi,%rsi
jae    11d1 <denoise_DWTAnlz+0xb1>
lea    (%r14,%rax,4),%rsi
lea    0x4(%rbx),%rdi
cmp    %rsi,%rdi
jb     1240 <denoise_DWTAnlz+0x120>
mov    %rdx,%rsi
and    $0xfffffffffffffff8,%rsi
lea    0x1(%rsi),%rcx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
movaps %xmm8,%xmm2
shufps $0x0,%xmm8,%xmm2
xor    %edi,%edi
xchg   %ax,%ax
movups 0x4(%rbx,%rdi,4),%xmm3
movups 0x14(%rbx,%rdi,4),%xmm4
movaps %xmm1,%xmm5
cmpltps %xmm3,%xmm5
movaps %xmm1,%xmm6
cmpltps %xmm4,%xmm6
movaps %xmm3,%xmm7
cmpltps %xmm2,%xmm7
orps   %xmm5,%xmm7
movaps %xmm4,%xmm5
cmpltps %xmm2,%xmm5
orps   %xmm6,%xmm5
andps  %xmm3,%xmm7
andps  %xmm4,%xmm5
movups %xmm7,0x4(%r14,%rdi,4)
movups %xmm5,0x14(%r14,%rdi,4)
add    $0x8,%rdi
cmp    %rdi,%rsi
jne    11f0 <denoise_DWTAnlz+0xd0>
cmp    %rsi,%rdx
je     12e1 <denoise_DWTAnlz+0x1c1>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
jne    1279 <denoise_DWTAnlz+0x159>
movss  (%rbx,%rcx,4),%xmm1
movaps %xmm0,%xmm2
cmpltss %xmm1,%xmm2
movaps %xmm2,%xmm3
andps  %xmm1,%xmm3
movaps %xmm1,%xmm4
cmpltss %xmm8,%xmm4
andps  %xmm1,%xmm4
andnps %xmm4,%xmm2
orps   %xmm3,%xmm2
movss  %xmm2,(%r14,%rcx,4)
add    $0x1,%rcx
add    %rax,%rdx
je     12e1 <denoise_DWTAnlz+0x1c1>
xchg   %ax,%ax
movss  (%rbx,%rcx,4),%xmm1
movaps %xmm0,%xmm2
cmpltss %xmm1,%xmm2
movaps %xmm2,%xmm3
andps  %xmm1,%xmm3
movaps %xmm1,%xmm4
cmpltss %xmm8,%xmm4
andps  %xmm1,%xmm4
andnps %xmm4,%xmm2
orps   %xmm3,%xmm2
movss  %xmm2,(%r14,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm1
movaps %xmm0,%xmm2
cmpltss %xmm1,%xmm2
movaps %xmm2,%xmm3
andps  %xmm1,%xmm3
movaps %xmm1,%xmm4
cmpltss %xmm8,%xmm4
andps  %xmm1,%xmm4
andnps %xmm4,%xmm2
orps   %xmm3,%xmm2
movss  %xmm2,0x4(%r14,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1280 <denoise_DWTAnlz+0x160>
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define void @denoise_DWTAnlz(float* %0, float* %1, i32 %2, float %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca i32
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca i32
store float* %0, float** %5
store float* %1, float** %6
store i32 %2, i32* %7
store float %3, float* %8
%12 = load float*, float** %5
%13 = load i32, i32* %7
%14 = call float @mean_DWTAnlz(float* %12, i32 %13, i32* null)
%15 = load float, float* %8
%16 = load float*, float** %5
%17 = load i32, i32* %7
%18 = call float @stddev_DWTAnlz(float* %16, i32 %17, i32* null)
%19 = fneg float %15
%20 = call float @llvm.fmuladd.f32(float %19, float %18, float %14)
store float %20, float* %9
%21 = load float*, float** %5
%22 = load i32, i32* %7
%23 = call float @mean_DWTAnlz(float* %21, i32 %22, i32* null)
%24 = load float, float* %8
%25 = load float*, float** %5
%26 = load i32, i32* %7
%27 = call float @stddev_DWTAnlz(float* %25, i32 %26, i32* null)
%28 = call float @llvm.fmuladd.f32(float %24, float %27, float %23)
store float %28, float* %10
store i32 1, i32* %11
br label %29
29: ; preds = %65, %4
%30 = load i32, i32* %11
%31 = load i32, i32* %7
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %68
33: ; preds = %29
%34 = load float*, float** %5
%35 = load i32, i32* %11
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds float, float* %34, i64 %36
%38 = load float, float* %37
%39 = load float, float* %10
%40 = fcmp ogt float %38, %39
br i1 %40, label %49, label %41
41: ; preds = %33
%42 = load float*, float** %5
%43 = load i32, i32* %11
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds float, float* %42, i64 %44
%46 = load float, float* %45
%47 = load float, float* %9
%48 = fcmp olt float %46, %47
br i1 %48, label %49, label %59
49: ; preds = %41, %33
%50 = load float*, float** %5
%51 = load i32, i32* %11
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float, float* %50, i64 %52
%54 = load float, float* %53
%55 = load float*, float** %6
%56 = load i32, i32* %11
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds float, float* %55, i64 %57
store float %54, float* %58
br label %64
59: ; preds = %41
%60 = load float*, float** %6
%61 = load i32, i32* %11
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %60, i64 %62
store float 0.000000e+00, float* %63
br label %64
64: ; preds = %59, %49
br label %65
65: ; preds = %64
%66 = load i32, i32* %11
%67 = add nsw i32 %66, 1
store i32 %67, i32* %11
br label %29
68: ; preds = %29
ret void
}

LLVM IR (-O2):
define void @denoise_DWTAnlz(float* %0, float* nocapture writeonly %1, i32 %2, float %3) {
%5 = tail call float @mean_DWTAnlz(float* %0, i32 %2, i32* null)
%6 = tail call float @stddev_DWTAnlz(float* %0, i32 %2, i32* null)
%7 = fneg float %3
%8 = tail call float @llvm.fmuladd.f32(float %7, float %6, float %5)
%9 = tail call float @mean_DWTAnlz(float* %0, i32 %2, i32* null)
%10 = tail call float @stddev_DWTAnlz(float* %0, i32 %2, i32* null)
%11 = tail call float @llvm.fmuladd.f32(float %3, float %10, float %9)
%12 = icmp sgt i32 %2, 1
br i1 %12, label %13, label %79
13: ; preds = %4
%14 = zext i32 %2 to i64
%15 = add nsw i64 %14, -1
%16 = icmp ult i64 %15, 8
br i1 %16, label %61, label %17
17: ; preds = %13
%18 = getelementptr float, float* %1, i64 1
%19 = getelementptr float, float* %1, i64 %14
%20 = getelementptr float, float* %0, i64 1
%21 = getelementptr float, float* %0, i64 %14
%22 = icmp ult float* %18, %21
%23 = icmp ult float* %20, %19
%24 = and i1 %22, %23
br i1 %24, label %61, label %25
25: ; preds = %17
%26 = and i64 %15, -8
%27 = or i64 %26, 1
%28 = insertelement <4 x float> poison, float %11, i64 0
%29 = shufflevector <4 x float> %28, <4 x float> poison, <4 x i32> zeroinitializer
%30 = insertelement <4 x float> poison, float %11, i64 0
%31 = shufflevector <4 x float> %30, <4 x float> poison, <4 x i32> zeroinitializer
%32 = insertelement <4 x float> poison, float %8, i64 0
%33 = shufflevector <4 x float> %32, <4 x float> poison, <4 x i32> zeroinitializer
%34 = insertelement <4 x float> poison, float %8, i64 0
%35 = shufflevector <4 x float> %34, <4 x float> poison, <4 x i32> zeroinitializer
br label %36
36: ; preds = %36, %25
%37 = phi i64 [ 0, %25 ], [ %57, %36 ]
%38 = or i64 %37, 1
%39 = getelementptr inbounds float, float* %0, i64 %38
%40 = bitcast float* %39 to <4 x float>*
%41 = load <4 x float>, <4 x float>* %40
%42 = getelementptr inbounds float, float* %39, i64 4
%43 = bitcast float* %42 to <4 x float>*
%44 = load <4 x float>, <4 x float>* %43
%45 = fcmp ogt <4 x float> %41, %29
%46 = fcmp ogt <4 x float> %44, %31
%47 = fcmp olt <4 x float> %41, %33
%48 = fcmp olt <4 x float> %44, %35
%49 = select <4 x i1> %45, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %47
%50 = select <4 x i1> %46, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %48
%51 = select <4 x i1> %49, <4 x float> %41, <4 x float> zeroinitializer
%52 = select <4 x i1> %50, <4 x float> %44, <4 x float> zeroinitializer
%53 = getelementptr inbounds float, float* %1, i64 %38
%54 = bitcast float* %53 to <4 x float>*
store <4 x float> %51, <4 x float>* %54
%55 = getelementptr inbounds float, float* %53, i64 4
%56 = bitcast float* %55 to <4 x float>*
store <4 x float> %52, <4 x float>* %56
%57 = add nuw i64 %37, 8
%58 = icmp eq i64 %57, %26
br i1 %58, label %59, label %36
59: ; preds = %36
%60 = icmp eq i64 %15, %26
br i1 %60, label %79, label %61
61: ; preds = %17, %13, %59
%62 = phi i64 [ 1, %17 ], [ 1, %13 ], [ %27, %59 ]
%63 = xor i64 %62, -1
%64 = and i64 %14, 1
%65 = icmp eq i64 %64, 0
br i1 %65, label %66, label %75
66: ; preds = %61
%67 = getelementptr inbounds float, float* %0, i64 %62
%68 = load float, float* %67
%69 = fcmp ogt float %68, %11
%70 = fcmp olt float %68, %8
%71 = select i1 %69, i1 true, i1 %70
%72 = select i1 %71, float %68, float 0.000000e+00
%73 = getelementptr inbounds float, float* %1, i64 %62
store float %72, float* %73
%74 = add nuw nsw i64 %62, 1
br label %75
75: ; preds = %66, %61
%76 = phi i64 [ %62, %61 ], [ %74, %66 ]
%77 = sub nsw i64 0, %14
%78 = icmp eq i64 %63, %77
br i1 %78, label %79, label %80
79: ; preds = %75, %80, %59, %4
ret void
80: ; preds = %75, %80
%81 = phi i64 [ %97, %80 ], [ %76, %75 ]
%82 = getelementptr inbounds float, float* %0, i64 %81
%83 = load float, float* %82
%84 = fcmp ogt float %83, %11
%85 = fcmp olt float %83, %8
%86 = select i1 %84, i1 true, i1 %85
%87 = select i1 %86, float %83, float 0.000000e+00
%88 = getelementptr inbounds float, float* %1, i64 %81
store float %87, float* %88
%89 = add nuw nsw i64 %81, 1
%90 = getelementptr inbounds float, float* %0, i64 %89
%91 = load float, float* %90
%92 = fcmp ogt float %91, %11
%93 = fcmp olt float %91, %8
%94 = select i1 %92, i1 true, i1 %93
%95 = select i1 %94, float %91, float 0.000000e+00
%96 = getelementptr inbounds float, float* %1, i64 %89
store float %95, float* %96
%97 = add nuw nsw i64 %81, 2
%98 = icmp eq i64 %97, %14
br i1 %98, label %79, label %80
}