#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 */
scalar_t__ sqrt(float);
void avestd(float data[], unsigned long n, float missing, float *ave,
            float *std) {
  unsigned long j;
  float s, ep, var;
  unsigned long count = 0;
  for (*ave = 0.0F, j = 1; j <= n; j++)
    if (data[j] != missing) {
      *ave += data[j];
      count++;
    }
  *ave /= (float)count;
  var = ep = 0.0F;
  for (j = 1; j <= n; j++)
    if (data[j] != missing) {
      s = data[j] - (*ave);
      ep += s;
      var += s * s;
    }
  if (count > 1)
    var = (var - ep * ep / (float)count) / (count - 1.0F);
  else
    var = 0.0F;
  *std = (float)sqrt(var);
}


x86 assembly (clang, -O0):
<avestd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
ja     11b3 <avestd+0xa3>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x14(%rbp),%xmm0
jne    1178 <avestd+0x68>
jp     1178 <avestd+0x68>
jmp    119d <avestd+0x8d>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    11a2 <avestd+0x92>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1148 <avestd+0x38>
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x50(%rbp)
test   %rax,%rax
movss  %xmm0,-0x4c(%rbp)
js     11f0 <avestd+0xe0>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
ja     12a8 <avestd+0x198>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x14(%rbp),%xmm0
jne    124d <avestd+0x13d>
jp     124d <avestd+0x13d>
jmp    1292 <avestd+0x182>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    1297 <avestd+0x187>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    121d <avestd+0x10d>
cmpq   $0x1,-0x48(%rbp)
jbe    1339 <avestd+0x229>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x58(%rbp)
test   %rax,%rax
movss  %xmm0,-0x54(%rbp)
js     1308 <avestd+0x1f8>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
divss  %xmm1,%xmm2
subss  %xmm2,%xmm0
movss  0xcd9(%rip),%xmm2
subss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    1341 <avestd+0x231>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
call   1030 <sqrt@plt>
cvtsi2ss %rax,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<avestd>:
push   %r14
push   %rbx
push   %rax
mov    %rcx,%r14
movl   $0x0,(%rdx)
test   %rsi,%rsi
je     1195 <avestd+0x85>
mov    %rsi,%r8
add    $0xffffffffffffffff,%r8
je     11a4 <avestd+0x94>
mov    %rsi,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
mov    $0x1,%ebx
xorps  %xmm2,%xmm2
xor    %r9d,%r9d
jmp    1162 <avestd+0x52>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rcx,%rbx,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
je     11af <avestd+0x9f>
movss  (%rdi,%rbx,4),%xmm1
ucomiss %xmm0,%xmm1
jne    116e <avestd+0x5e>
jnp    117a <avestd+0x6a>
addss  %xmm1,%xmm2
movss  %xmm2,(%rdx)
add    $0x1,%r9
movss  0x4(%rdi,%rbx,4),%xmm1
ucomiss %xmm0,%xmm1
jne    1187 <avestd+0x77>
jnp    1150 <avestd+0x40>
addss  %xmm1,%xmm2
movss  %xmm2,(%rdx)
add    $0x1,%r9
jmp    1150 <avestd+0x40>
movl   $0x7fc00000,(%rdx)
xorps  %xmm8,%xmm8
jmp    1314 <avestd+0x204>
xor    %r9d,%r9d
mov    $0x1,%ebx
xorps  %xmm2,%xmm2
test   $0x1,%sil
je     11cd <avestd+0xbd>
movss  (%rdi,%rbx,4),%xmm1
ucomiss %xmm0,%xmm1
jne    11c1 <avestd+0xb1>
jnp    11cd <avestd+0xbd>
addss  %xmm1,%xmm2
movss  %xmm2,(%rdx)
add    $0x1,%r9
test   %r9,%r9
js     11d9 <avestd+0xc9>
cvtsi2ss %r9,%xmm9
jmp    11f2 <avestd+0xe2>
mov    %r9,%rax
shr    %rax
mov    %r9d,%ecx
and    $0x1,%ecx
or     %rax,%rcx
cvtsi2ss %rcx,%xmm9
addss  %xmm9,%xmm9
divss  %xmm9,%xmm2
movss  %xmm2,(%rdx)
xorps  %xmm8,%xmm8
xorps  %xmm4,%xmm4
xorps  %xmm5,%xmm5
test   %rsi,%rsi
je     12ef <avestd+0x1df>
test   %r8,%r8
je     12ad <avestd+0x19d>
mov    %rsi,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
xorps  %xmm5,%xmm5
movss  0xdcf(%rip),%xmm3
xorps  %xmm4,%xmm4
jmp    125a <avestd+0x14a>
cs nopw 0x0(%rax,%rax,1)
addss  %xmm6,%xmm4
addss  %xmm1,%xmm4
lea    (%rdx,%rcx,1),%rax
add    $0x2,%rax
add    $0x2,%rcx
cmp    $0x1,%rax
je     12b8 <avestd+0x1a8>
movss  (%rdi,%rcx,4),%xmm7
ucomiss %xmm7,%xmm0
subss  %xmm2,%xmm7
movaps %xmm7,%xmm6
jne    1273 <avestd+0x163>
movaps %xmm7,%xmm6
jp     1273 <avestd+0x163>
movaps %xmm3,%xmm6
mulss  %xmm7,%xmm7
addss  %xmm5,%xmm7
jne    1282 <avestd+0x172>
jp     1282 <avestd+0x172>
movaps %xmm5,%xmm7
movss  0x4(%rdi,%rcx,4),%xmm5
ucomiss %xmm5,%xmm0
subss  %xmm2,%xmm5
movaps %xmm5,%xmm1
jne    129c <avestd+0x18c>
movaps %xmm5,%xmm1
jp     129c <avestd+0x18c>
movaps %xmm3,%xmm1
mulss  %xmm5,%xmm5
addss  %xmm7,%xmm5
jne    1240 <avestd+0x130>
jp     1240 <avestd+0x130>
movaps %xmm7,%xmm5
jmp    1240 <avestd+0x130>
mov    $0x1,%ecx
xorps  %xmm5,%xmm5
xorps  %xmm4,%xmm4
test   $0x1,%sil
je     12ef <avestd+0x1df>
movss  (%rdi,%rcx,4),%xmm1
ucomiss %xmm1,%xmm0
subss  %xmm2,%xmm1
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
jne    12dd <avestd+0x1cd>
jp     12dd <avestd+0x1cd>
movss  0xd23(%rip),%xmm1
addss  %xmm5,%xmm0
jne    12e8 <avestd+0x1d8>
jp     12e8 <avestd+0x1d8>
movaps %xmm5,%xmm0
addss  %xmm1,%xmm4
movaps %xmm0,%xmm5
cmp    $0x2,%r9
jb     1314 <avestd+0x204>
mulss  %xmm4,%xmm4
divss  %xmm9,%xmm4
subss  %xmm4,%xmm5
addss  0xcf9(%rip),%xmm9
divss  %xmm9,%xmm5
movaps %xmm5,%xmm8
movaps %xmm8,%xmm0
call   1030 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

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