#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 sqrt(double);
int floatweightedmeanrms(int ndat, float *dat, float *weight, float *mean,
                         float *sigma) {
  int i;
  double x;
  double sx = 0;
  double sx2 = 0;
  double w = 0;
  for (i = 0; i < ndat; i++) {
    x = dat[i] - sx;
    sx += x * (double)weight[i] / ((double)weight[i] + w);
    sx2 += x * x * (double)weight[i] * w / ((double)weight[i] + w);
    w += weight[i];
  }
  *mean = sx;
  if (w > 0)
    *sigma = sqrt(sx2 / w);
  return 0;
}


x86 assembly (clang, -O0):
<floatweightedmeanrms>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1220 <floatweightedmeanrms+0x110>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114a <floatweightedmeanrms+0x3a>
movsd  -0x40(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    125a <floatweightedmeanrms+0x14a>
movsd  -0x48(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
call   1030 <sqrt@plt>
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<floatweightedmeanrms>:
push   %rbx
test   %edi,%edi
jle    11af <floatweightedmeanrms+0x9f>
mov    %r8,%rbx
mov    %edi,%eax
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm2
movapd %xmm1,%xmm3
movss  (%rsi,%rdi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movapd %xmm2,%xmm4
unpckhpd %xmm2,%xmm4
subsd  %xmm4,%xmm0
movss  (%rdx,%rdi,4),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm4,%xmm1
unpcklpd %xmm0,%xmm3
mulsd  %xmm0,%xmm0
mulsd  %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
mulpd  %xmm3,%xmm0
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
divpd  %xmm3,%xmm0
addpd  %xmm2,%xmm0
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1130 <floatweightedmeanrms+0x20>
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%rcx)
xorps  %xmm2,%xmm2
ucomisd %xmm2,%xmm1
jbe    11b5 <floatweightedmeanrms+0xa5>
divsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,(%rbx)
jmp    11b5 <floatweightedmeanrms+0xa5>
movl   $0x0,(%rcx)
xor    %eax,%eax
pop    %rbx
ret

LLVM IR (-O0):
define i32 @floatweightedmeanrms(i32 %0, float* %1, float* %2, float* %3, float* %4) {
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca i32
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
store i32 %0, i32* %6
store float* %1, float** %7
store float* %2, float** %8
store float* %3, float** %9
store float* %4, float** %10
store double 0.000000e+00, double* %13
store double 0.000000e+00, double* %14
store double 0.000000e+00, double* %15
store i32 0, i32* %11
br label %16
16: ; preds = %79, %5
%17 = load i32, i32* %11
%18 = load i32, i32* %6
%19 = icmp slt i32 %17, %18
br i1 %19, label %20, label %82
20: ; preds = %16
%21 = load float*, float** %7
%22 = load i32, i32* %11
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float, float* %21, i64 %23
%25 = load float, float* %24
%26 = fpext float %25 to double
%27 = load double, double* %13
%28 = fsub double %26, %27
store double %28, double* %12
%29 = load double, double* %12
%30 = load float*, float** %8
%31 = load i32, i32* %11
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds float, float* %30, i64 %32
%34 = load float, float* %33
%35 = fpext float %34 to double
%36 = fmul double %29, %35
%37 = load float*, float** %8
%38 = load i32, i32* %11
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds float, float* %37, i64 %39
%41 = load float, float* %40
%42 = fpext float %41 to double
%43 = load double, double* %15
%44 = fadd double %42, %43
%45 = fdiv double %36, %44
%46 = load double, double* %13
%47 = fadd double %46, %45
store double %47, double* %13
%48 = load double, double* %12
%49 = load double, double* %12
%50 = fmul double %48, %49
%51 = load float*, float** %8
%52 = load i32, i32* %11
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %51, i64 %53
%55 = load float, float* %54
%56 = fpext float %55 to double
%57 = fmul double %50, %56
%58 = load double, double* %15
%59 = fmul double %57, %58
%60 = load float*, float** %8
%61 = load i32, i32* %11
%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* %15
%67 = fadd double %65, %66
%68 = fdiv double %59, %67
%69 = load double, double* %14
%70 = fadd double %69, %68
store double %70, double* %14
%71 = load float*, float** %8
%72 = load i32, i32* %11
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %71, i64 %73
%75 = load float, float* %74
%76 = fpext float %75 to double
%77 = load double, double* %15
%78 = fadd double %77, %76
store double %78, double* %15
br label %79
79: ; preds = %20
%80 = load i32, i32* %11
%81 = add nsw i32 %80, 1
store i32 %81, i32* %11
br label %16
82: ; preds = %16
%83 = load double, double* %13
%84 = fptrunc double %83 to float
%85 = load float*, float** %9
store float %84, float* %85
%86 = load double, double* %15
%87 = fcmp ogt double %86, 0.000000e+00
br i1 %87, label %88, label %94
88: ; preds = %82
%89 = load double, double* %14
%90 = load double, double* %15
%91 = fdiv double %89, %90
%92 = call float @sqrt(double %91)
%93 = load float*, float** %10
store float %92, float* %93
br label %94
94: ; preds = %88, %82
ret i32 0
}

LLVM IR (-O2):
define i32 @floatweightedmeanrms(i32 %0, float* nocapture %1, float* nocapture %2, float* nocapture writeonly %3, float* nocapture writeonly %4) {
%6 = icmp sgt i32 %0, 0
br i1 %6, label %8, label %7
7: ; preds = %5
store float 0.000000e+00, float* %3
br label %44
8: ; preds = %5
%9 = zext i32 %0 to i64
br label %10
10: ; preds = %8, %10
%11 = phi i64 [ 0, %8 ], [ %34, %10 ]
%12 = phi double [ 0.000000e+00, %8 ], [ %22, %10 ]
%13 = phi <2 x double> [ zeroinitializer, %8 ], [ %33, %10 ]
%14 = getelementptr inbounds float, float* %1, i64 %11
%15 = load float, float* %14
%16 = fpext float %15 to double
%17 = extractelement <2 x double> %13, i64 1
%18 = fsub double %16, %17
%19 = getelementptr inbounds float, float* %2, i64 %11
%20 = load float, float* %19
%21 = fpext float %20 to double
%22 = fadd double %12, %21
%23 = fmul double %18, %18
%24 = fmul double %23, %21
%25 = insertelement <2 x double> poison, double %12, i64 0
%26 = insertelement <2 x double> %25, double %18, i64 1
%27 = insertelement <2 x double> poison, double %24, i64 0
%28 = insertelement <2 x double> %27, double %21, i64 1
%29 = fmul <2 x double> %26, %28
%30 = insertelement <2 x double> poison, double %22, i64 0
%31 = shufflevector <2 x double> %30, <2 x double> poison, <2 x i32> zeroinitializer
%32 = fdiv <2 x double> %29, %31
%33 = fadd <2 x double> %13, %32
%34 = add nuw nsw i64 %11, 1
%35 = icmp eq i64 %34, %9
br i1 %35, label %36, label %10
36: ; preds = %10
%37 = extractelement <2 x double> %33, i64 1
%38 = fptrunc double %37 to float
store float %38, float* %3
%39 = fcmp ogt double %22, 0.000000e+00
br i1 %39, label %40, label %44
40: ; preds = %36
%41 = extractelement <2 x double> %33, i64 0
%42 = fdiv double %41, %22
%43 = tail call float @sqrt(double %42)
store float %43, float* %4
br label %44
44: ; preds = %7, %40, %36
ret i32 0
}