#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*/ isinff(float);
int /*<<< orphan*/ isnanf(float);
void arr_float_average_stages_pos(float *pDest, float *pSrc,
                                  unsigned long int uStates,
                                  unsigned long int uStages) {
  float fTol = 1E-3;
  unsigned short int i, j, k;
  for (i = 0; i < uStates; i++) {
    k = 0;
    pDest[i] = 0;
    for (j = 0; j < uStages; j++) {
      float v = pSrc[j * uStates + i];
      if (!isnanf(v) && !isinff(v)) {
        if (v > fTol) {
          pDest[i] += v;
          k++;
        }
      }
    }
    if (k > 0) {
      pDest[i] /= k;
    }
  }
}


x86 assembly (clang, -O0):
<arr_float_average_stages_pos>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movss  0xec0(%rip),%xmm0
movss  %xmm0,-0x24(%rbp)
movw   $0x0,-0x26(%rbp)
movzwl -0x26(%rbp),%eax
cmp    -0x18(%rbp),%rax
jae    1255 <arr_float_average_stages_pos+0x135>
movw   $0x0,-0x2a(%rbp)
mov    -0x8(%rbp),%rax
movzwl -0x26(%rbp),%ecx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movw   $0x0,-0x28(%rbp)
movzwl -0x28(%rbp),%eax
cmp    -0x20(%rbp),%rax
jae    1214 <arr_float_average_stages_pos+0xf4>
mov    -0x10(%rbp),%rax
movzwl -0x28(%rbp),%ecx
imul   -0x18(%rbp),%rcx
movzwl -0x26(%rbp),%edx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
call   1030 <isnanf@plt>
cmp    $0x0,%eax
jne    11fe <arr_float_average_stages_pos+0xde>
movss  -0x30(%rbp),%xmm0
call   1040 <isinff@plt>
cmp    $0x0,%eax
jne    11fe <arr_float_average_stages_pos+0xde>
movss  -0x30(%rbp),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    11f9 <arr_float_average_stages_pos+0xd9>
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movzwl -0x26(%rbp),%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2a(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2a(%rbp)
jmp    11fe <arr_float_average_stages_pos+0xde>
jmp    1203 <arr_float_average_stages_pos+0xe3>
mov    -0x28(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x28(%rbp)
jmp    1175 <arr_float_average_stages_pos+0x55>
movzwl -0x2a(%rbp),%eax
cmp    $0x0,%eax
jle    123f <arr_float_average_stages_pos+0x11f>
movzwl -0x2a(%rbp),%eax
cvtsi2ss %eax,%xmm1
mov    -0x8(%rbp),%rax
movzwl -0x26(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1244 <arr_float_average_stages_pos+0x124>
mov    -0x26(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x26(%rbp)
jmp    114b <arr_float_average_stages_pos+0x2b>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<arr_float_average_stages_pos>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,0x10(%rsp)
test   %rdx,%rdx
je     120b <arr_float_average_stages_pos+0xeb>
mov    %rcx,%r14
mov    %rdx,%r13
mov    %rsi,%r15
xor    %ebx,%ebx
jmp    115f <arr_float_average_stages_pos+0x3f>
nopl   0x0(%rax)
add    $0x1,%ebx
movzwl %bx,%ebx
cmp    %r13,%rbx
jae    120b <arr_float_average_stages_pos+0xeb>
mov    0x10(%rsp),%rax
movl   $0x0,(%rax,%rbx,4)
test   %r14,%r14
je     1150 <arr_float_average_stages_pos+0x30>
xor    %r12d,%r12d
xor    %ebp,%ebp
jmp    118d <arr_float_average_stages_pos+0x6d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12d
movzwl %r12w,%r12d
cmp    %r14,%r12
jae    11e0 <arr_float_average_stages_pos+0xc0>
mov    %r12,%rax
imul   %r13,%rax
add    %rbx,%rax
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,0xc(%rsp)
call   1030 <isnanf@plt>
test   %eax,%eax
jne    1180 <arr_float_average_stages_pos+0x60>
movss  0xc(%rsp),%xmm0
call   1040 <isinff@plt>
movss  0xc(%rsp),%xmm0
ucomiss 0xe3c(%rip),%xmm0
jbe    1180 <arr_float_average_stages_pos+0x60>
test   %eax,%eax
jne    1180 <arr_float_average_stages_pos+0x60>
mov    0x10(%rsp),%rax
addss  (%rax,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%ebp
jmp    1180 <arr_float_average_stages_pos+0x60>
xchg   %ax,%ax
test   %bp,%bp
je     1150 <arr_float_average_stages_pos+0x30>
movzwl %bp,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x10(%rsp),%rax
movss  (%rax,%rbx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rbx,4)
jmp    1150 <arr_float_average_stages_pos+0x30>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @arr_float_average_stages_pos(float* %0, float* %1, i64 %2, i64 %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca i64
%8 = alloca i64
%9 = alloca float
%10 = alloca i16
%11 = alloca i16
%12 = alloca i16
%13 = alloca float
store float* %0, float** %5
store float* %1, float** %6
store i64 %2, i64* %7
store i64 %3, i64* %8
store float 0x3F50624DE0000000, float* %9
store i16 0, i16* %10
br label %14
14: ; preds = %81, %4
%15 = load i16, i16* %10
%16 = zext i16 %15 to i64
%17 = load i64, i64* %7
%18 = icmp ult i64 %16, %17
br i1 %18, label %19, label %84
19: ; preds = %14
store i16 0, i16* %12
%20 = load float*, float** %5
%21 = load i16, i16* %10
%22 = zext i16 %21 to i64
%23 = getelementptr inbounds float, float* %20, i64 %22
store float 0.000000e+00, float* %23
store i16 0, i16* %11
br label %24
24: ; preds = %63, %19
%25 = load i16, i16* %11
%26 = zext i16 %25 to i64
%27 = load i64, i64* %8
%28 = icmp ult i64 %26, %27
br i1 %28, label %29, label %66
29: ; preds = %24
%30 = load float*, float** %6
%31 = load i16, i16* %11
%32 = zext i16 %31 to i64
%33 = load i64, i64* %7
%34 = mul i64 %32, %33
%35 = load i16, i16* %10
%36 = zext i16 %35 to i64
%37 = add i64 %34, %36
%38 = getelementptr inbounds float, float* %30, i64 %37
%39 = load float, float* %38
store float %39, float* %13
%40 = load float, float* %13
%41 = call i32 @isnanf(float %40)
%42 = icmp ne i32 %41, 0
br i1 %42, label %62, label %43
43: ; preds = %29
%44 = load float, float* %13
%45 = call i32 @isinff(float %44)
%46 = icmp ne i32 %45, 0
br i1 %46, label %62, label %47
47: ; preds = %43
%48 = load float, float* %13
%49 = load float, float* %9
%50 = fcmp ogt float %48, %49
br i1 %50, label %51, label %61
51: ; preds = %47
%52 = load float, float* %13
%53 = load float*, float** %5
%54 = load i16, i16* %10
%55 = zext i16 %54 to i64
%56 = getelementptr inbounds float, float* %53, i64 %55
%57 = load float, float* %56
%58 = fadd float %57, %52
store float %58, float* %56
%59 = load i16, i16* %12
%60 = add i16 %59, 1
store i16 %60, i16* %12
br label %61
61: ; preds = %51, %47
br label %62
62: ; preds = %61, %43, %29
br label %63
63: ; preds = %62
%64 = load i16, i16* %11
%65 = add i16 %64, 1
store i16 %65, i16* %11
br label %24
66: ; preds = %24
%67 = load i16, i16* %12
%68 = zext i16 %67 to i32
%69 = icmp sgt i32 %68, 0
br i1 %69, label %70, label %80
70: ; preds = %66
%71 = load i16, i16* %12
%72 = zext i16 %71 to i32
%73 = sitofp i32 %72 to float
%74 = load float*, float** %5
%75 = load i16, i16* %10
%76 = zext i16 %75 to i64
%77 = getelementptr inbounds float, float* %74, i64 %76
%78 = load float, float* %77
%79 = fdiv float %78, %73
store float %79, float* %77
br label %80
80: ; preds = %70, %66
br label %81
81: ; preds = %80
%82 = load i16, i16* %10
%83 = add i16 %82, 1
store i16 %83, i16* %10
br label %14
84: ; preds = %14
ret void
}

LLVM IR (-O2):
define void @arr_float_average_stages_pos(float* nocapture %0, float* nocapture %1, i64 %2, i64 %3) {
%5 = icmp eq i64 %2, 0
br i1 %5, label %44, label %6
6: ; preds = %4
%7 = icmp eq i64 %3, 0
br label %8
8: ; preds = %6, %40
%9 = phi i64 [ 0, %6 ], [ %42, %40 ]
%10 = getelementptr inbounds float, float* %0, i64 %9
store float 0.000000e+00, float* %10
br i1 %7, label %40, label %11
11: ; preds = %8, %29
%12 = phi i64 [ %32, %29 ], [ 0, %8 ]
%13 = phi i16 [ %30, %29 ], [ 0, %8 ]
%14 = mul i64 %12, %2
%15 = add i64 %14, %9
%16 = getelementptr inbounds float, float* %1, i64 %15
%17 = load float, float* %16
%18 = tail call i32 @isnanf(float %17)
%19 = icmp eq i32 %18, 0
br i1 %19, label %20, label %29
20: ; preds = %11
%21 = tail call i32 @isinff(float %17)
%22 = icmp eq i32 %21, 0
%23 = fcmp ogt float %17, 0x3F50624DE0000000
%24 = and i1 %23, %22
br i1 %24, label %25, label %29
25: ; preds = %20
%26 = load float, float* %10
%27 = fadd float %17, %26
store float %27, float* %10
%28 = add i16 %13, 1
br label %29
29: ; preds = %25, %20, %11
%30 = phi i16 [ %13, %11 ], [ %13, %20 ], [ %28, %25 ]
%31 = add nuw nsw i64 %12, 1
%32 = and i64 %31, 65535
%33 = icmp ult i64 %32, %3
br i1 %33, label %11, label %34
34: ; preds = %29
%35 = icmp eq i16 %30, 0
br i1 %35, label %40, label %36
36: ; preds = %34
%37 = uitofp i16 %30 to float
%38 = load float, float* %10
%39 = fdiv float %38, %37
store float %39, float* %10
br label %40
40: ; preds = %8, %34, %36
%41 = add nuw nsw i64 %9, 1
%42 = and i64 %41, 65535
%43 = icmp ult i64 %42, %2
br i1 %43, label %8, label %44
44: ; preds = %40, %4
ret void
}