#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*/ assert(float *);
scalar_t__ calloc(int, int);
scalar_t__ pow(float, int);
float *extractMoments(float *data, int num_elts, int num_moments) {
  int i;
  int j;
  float *moments;
  moments = (float *)calloc(num_moments, sizeof(float));
  assert(moments);
  for (i = 0; i < num_elts; i++) {
    moments[0] += data[i];
  }
  moments[0] = moments[0] / num_elts;
  for (j = 1; j < num_moments; j++) {
    moments[j] = 0;
    for (i = 0; i < num_elts; i++) {
      moments[j] += pow((data[i] - moments[0]), j + 1);
    }
    moments[j] = moments[j] / num_elts;
  }
  return moments;
}


x86 assembly (clang, -O0):
<extractMoments>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%edi
mov    $0x4,%esi
call   1030 <calloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
call   1040 <assert@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1196 <extractMoments+0x66>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1163 <extractMoments+0x33>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
cvtsi2ssl -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    125b <extractMoments+0x12b>
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    122a <extractMoments+0xfa>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
subss  (%rax),%xmm0
mov    -0x18(%rbp),%edi
add    $0x1,%edi
call   1050 <pow@plt>
cvtsi2ss %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11d9 <extractMoments+0xa9>
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11b6 <extractMoments+0x86>
mov    -0x20(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<extractMoments>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edx,%r15d
mov    %esi,%ebx
mov    %rdi,%r12
mov    %edx,%edi
mov    $0x4,%esi
call   1030 <calloc@plt>
mov    %rax,%rbp
mov    %rax,%rdi
call   1040 <assert@plt>
mov    %ebx,%esi
mov    %ebx,%edi
test   %ebx,%ebx
mov    %rdi,0x8(%rsp)
jle    1182 <extractMoments+0x52>
movss  0x0(%rbp),%xmm0
lea    -0x1(%rdi),%rcx
mov    %edi,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1189 <extractMoments+0x59>
xor    %ecx,%ecx
jmp    11c8 <extractMoments+0x98>
movss  0x0(%rbp),%xmm0
jmp    11f3 <extractMoments+0xc3>
mov    %edi,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
addss  (%r12,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp)
addss  0x4(%r12,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp)
addss  0x8(%r12,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp)
addss  0xc(%r12,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1190 <extractMoments+0x60>
test   %rax,%rax
je     11f3 <extractMoments+0xc3>
lea    (%r12,%rcx,4),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0x0(%rbp)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    11e0 <extractMoments+0xb0>
cvtsi2ss %esi,%xmm1
movss  %xmm1,0x4(%rsp)
divss  %xmm1,%xmm0
movss  %xmm0,0x0(%rbp)
cmp    $0x2,%r15d
jl     1315 <extractMoments+0x1e5>
mov    %r15d,%eax
mov    %rax,0x10(%rsp)
mov    0x8(%rsp),%r13
and    $0xfffffffe,%r13d
mov    $0x1,%r14d
mov    %esi,(%rsp)
jmp    124a <extractMoments+0x11a>
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
divss  0x4(%rsp),%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
cmp    0x10(%rsp),%r14
je     1315 <extractMoments+0x1e5>
mov    %r14,%rbx
add    $0x1,%r14
movl   $0x0,0x0(%rbp,%rbx,4)
test   %esi,%esi
jle    1230 <extractMoments+0x100>
cmp    $0x1,%esi
jne    1270 <extractMoments+0x140>
xor    %r15d,%r15d
jmp    12d8 <extractMoments+0x1a8>
nopw   0x0(%rax,%rax,1)
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r12,%r15,4),%xmm0
subss  0x0(%rbp),%xmm0
mov    %r14d,%edi
call   1050 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
movss  0x4(%r12,%r15,4),%xmm0
subss  0x0(%rbp),%xmm0
mov    %r14d,%edi
call   1050 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
add    $0x2,%r15
cmp    %r15,%r13
jne    1280 <extractMoments+0x150>
testb  $0x1,0x8(%rsp)
mov    (%rsp),%esi
je     1233 <extractMoments+0x103>
movss  (%r12,%r15,4),%xmm0
subss  0x0(%rbp),%xmm0
mov    %r14d,%edi
call   1050 <pow@plt>
mov    (%rsp),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
jmp    1233 <extractMoments+0x103>
mov    %rbp,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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