#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 meanValue(int arr[], size_t sz) {
  float res = 0;
  for (size_t i = 0; i < sz; i++) {
    res += (arr[i] - res) / (1 + i);
  }
  return res;
}


x86 assembly (clang, -O0):
<meanValue>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11ab <meanValue+0xab>
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
cvtsi2ssl (%rcx,%rax,4),%xmm0
movss  -0x14(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
add    $0x1,%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,-0x28(%rbp)
test   %rax,%rax
movss  %xmm0,-0x24(%rbp)
js     1182 <meanValue+0x82>
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
addss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    111c <meanValue+0x1c>
movss  -0x14(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<meanValue>:
test   %rsi,%rsi
je     113d <meanValue+0x3d>
cmp    $0x1,%rsi
jne    1141 <meanValue+0x41>
xorps  %xmm0,%xmm0
xor    %eax,%eax
test   $0x1,%sil
je     1200 <meanValue+0x100>
xorps  %xmm1,%xmm1
cvtsi2ssl (%rdi,%rax,4),%xmm1
subss  %xmm0,%xmm1
add    $0x1,%rax
js     11e0 <meanValue+0xe0>
xorps  %xmm2,%xmm2
cvtsi2ss %rax,%xmm2
jmp    11f8 <meanValue+0xf8>
xorps  %xmm0,%xmm0
ret
mov    %rsi,%r8
and    $0xfffffffffffffffe,%r8
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    1189 <meanValue+0x89>
nop
xorps  %xmm2,%xmm2
cvtsi2ss %rax,%xmm2
xorps  %xmm3,%xmm3
cvtsi2ssl (%rdi,%rdx,4),%xmm3
subss  %xmm0,%xmm3
divss  %xmm1,%xmm3
addss  %xmm0,%xmm3
xorps  %xmm0,%xmm0
cvtsi2ssl 0x4(%rdi,%rdx,4),%xmm0
subss  %xmm3,%xmm0
divss  %xmm2,%xmm0
addss  %xmm3,%xmm0
mov    %rax,%rdx
cmp    %rax,%r8
je     1110 <meanValue+0x10>
mov    %rdx,%rcx
add    $0x1,%rcx
js     11a0 <meanValue+0xa0>
xorps  %xmm1,%xmm1
cvtsi2ss %rcx,%xmm1
jmp    11b8 <meanValue+0xb8>
nopl   0x0(%rax)
mov    %rcx,%rax
shr    %rax
and    $0x1,%ecx
or     %rax,%rcx
xorps  %xmm1,%xmm1
cvtsi2ss %rcx,%xmm1
addss  %xmm1,%xmm1
mov    %rdx,%rax
add    $0x2,%rax
jns    1150 <meanValue+0x50>
mov    %rax,%r9
shr    %r9
mov    %eax,%ecx
and    $0x1,%ecx
or     %r9,%rcx
xorps  %xmm2,%xmm2
cvtsi2ss %rcx,%xmm2
addss  %xmm2,%xmm2
jmp    1158 <meanValue+0x58>
mov    %rax,%rcx
shr    %rcx
and    $0x1,%eax
or     %rcx,%rax
xorps  %xmm2,%xmm2
cvtsi2ss %rax,%xmm2
addss  %xmm2,%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
ret

LLVM IR (-O0):
define float @meanValue(i32* %0, i64 %1) {
%3 = alloca i32*
%4 = alloca i64
%5 = alloca float
%6 = alloca i64
store i32* %0, i32** %3
store i64 %1, i64* %4
store float 0.000000e+00, float* %5
store i64 0, i64* %6
br label %7
7: ; preds = %25, %2
%8 = load i64, i64* %6
%9 = load i64, i64* %4
%10 = icmp ult i64 %8, %9
br i1 %10, label %11, label %28
11: ; preds = %7
%12 = load i32*, i32** %3
%13 = load i64, i64* %6
%14 = getelementptr inbounds i32, i32* %12, i64 %13
%15 = load i32, i32* %14
%16 = sitofp i32 %15 to float
%17 = load float, float* %5
%18 = fsub float %16, %17
%19 = load i64, i64* %6
%20 = add i64 1, %19
%21 = uitofp i64 %20 to float
%22 = fdiv float %18, %21
%23 = load float, float* %5
%24 = fadd float %23, %22
store float %24, float* %5
br label %25
25: ; preds = %11
%26 = load i64, i64* %6
%27 = add i64 %26, 1
store i64 %27, i64* %6
br label %7
28: ; preds = %7
%29 = load float, float* %5
ret float %29
}

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