#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(int);
void compute_sum_sumsq(const float *data, double *sum, double *sumsq,
                       size_t d_length) {
  if (NULL == data) {
    return;
  };
  if (NULL == sum) {
    return;
  };
  if (NULL == sumsq) {
    return;
  };
  assert(d_length > 0);
  sum[0] = 0.0f;
  sumsq[0] = 0.0f;
  for (size_t i = 0; i < d_length; ++i) {
    sum[i + 1] = sum[i] + data[i];
    sumsq[i + 1] = sumsq[i] + data[i] * data[i];
  }
}


x86 assembly (clang, -O0):
<compute_sum_sumsq>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
xor    %eax,%eax
cmp    -0x8(%rbp),%rax
jne    1139 <compute_sum_sumsq+0x29>
jmp    1217 <compute_sum_sumsq+0x107>
xor    %eax,%eax
cmp    -0x10(%rbp),%rax
jne    114a <compute_sum_sumsq+0x3a>
jmp    1217 <compute_sum_sumsq+0x107>
xor    %eax,%eax
cmp    -0x18(%rbp),%rax
jne    115b <compute_sum_sumsq+0x4b>
jmp    1217 <compute_sum_sumsq+0x107>
cmpq   $0x0,-0x20(%rbp)
seta   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1217 <compute_sum_sumsq+0x107>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    118b <compute_sum_sumsq+0x7b>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_sum_sumsq>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
test   %rdi,%rdi
je     12ec <compute_sum_sumsq+0x1dc>
mov    %rsi,%rbx
test   %rsi,%rsi
je     12ec <compute_sum_sumsq+0x1dc>
mov    %rdx,%r14
test   %rdx,%rdx
je     12ec <compute_sum_sumsq+0x1dc>
mov    %rcx,%r12
mov    %rdi,%r15
xor    %edi,%edi
test   %rcx,%rcx
setne  %dil
call   1030 <assert@plt>
movq   $0x0,(%rbx)
movq   $0x0,(%r14)
test   %r12,%r12
je     12ec <compute_sum_sumsq+0x1dc>
lea    (%r14,%r12,8),%rax
add    $0x8,%rax
cmp    %rbx,%rax
jbe    118f <compute_sum_sumsq+0x7f>
lea    (%rbx,%r12,8),%rax
add    $0x8,%rax
cmp    %r14,%rax
jbe    118f <compute_sum_sumsq+0x7f>
cmp    $0x1,%r12
jne    1246 <compute_sum_sumsq+0x136>
xor    %ecx,%ecx
jmp    12b9 <compute_sum_sumsq+0x1a9>
movsd  (%rbx),%xmm1
movsd  (%r14),%xmm0
cmp    $0x1,%r12
jne    11a2 <compute_sum_sumsq+0x92>
xor    %ecx,%ecx
jmp    1211 <compute_sum_sumsq+0x101>
mov    %r12,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rdx,4),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x8(%rbx,%rdx,8)
mulss  %xmm2,%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%r14,%rdx,8)
movss  0x4(%r15,%rdx,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
addsd  %xmm3,%xmm1
lea    0x2(%rdx),%rcx
movsd  %xmm1,0x10(%rbx,%rdx,8)
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x10(%r14,%rdx,8)
mov    %rcx,%rdx
cmp    %rcx,%rax
jne    11b0 <compute_sum_sumsq+0xa0>
test   $0x1,%r12b
je     12ec <compute_sum_sumsq+0x1dc>
movss  (%r15,%rcx,4),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
addsd  %xmm3,%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
mulss  %xmm2,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
addsd  %xmm1,%xmm0
jmp    12e5 <compute_sum_sumsq+0x1d5>
mov    %r12,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
nop
movss  (%r15,%rdx,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
addsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rdx,8)
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rdx,8)
movss  0x4(%r15,%rdx,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
addsd  0x8(%rbx,%rdx,8),%xmm1
lea    0x2(%rdx),%rcx
movsd  %xmm1,0x10(%rbx,%rdx,8)
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x8(%r14,%rdx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rdx,8)
mov    %rcx,%rdx
cmp    %rcx,%rax
jne    1250 <compute_sum_sumsq+0x140>
test   $0x1,%r12b
je     12ec <compute_sum_sumsq+0x1dc>
movss  (%r15,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
addsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @compute_sum_sumsq(float* %0, double* %1, double* %2, i64 %3) {
%5 = alloca float*
%6 = alloca double*
%7 = alloca double*
%8 = alloca i64
%9 = alloca i64
store float* %0, float** %5
store double* %1, double** %6
store double* %2, double** %7
store i64 %3, i64* %8
%10 = load float*, float** %5
%11 = icmp eq float* null, %10
br i1 %11, label %12, label %13
12: ; preds = %4
br label %71
13: ; preds = %4
%14 = load double*, double** %6
%15 = icmp eq double* null, %14
br i1 %15, label %16, label %17
16: ; preds = %13
br label %71
17: ; preds = %13
%18 = load double*, double** %7
%19 = icmp eq double* null, %18
br i1 %19, label %20, label %21
20: ; preds = %17
br label %71
21: ; preds = %17
%22 = load i64, i64* %8
%23 = icmp ugt i64 %22, 0
%24 = zext i1 %23 to i32
%25 = call i32 @assert(i32 %24)
%26 = load double*, double** %6
%27 = getelementptr inbounds double, double* %26, i64 0
store double 0.000000e+00, double* %27
%28 = load double*, double** %7
%29 = getelementptr inbounds double, double* %28, i64 0
store double 0.000000e+00, double* %29
store i64 0, i64* %9
br label %30
30: ; preds = %68, %21
%31 = load i64, i64* %9
%32 = load i64, i64* %8
%33 = icmp ult i64 %31, %32
br i1 %33, label %34, label %71
34: ; preds = %30
%35 = load double*, double** %6
%36 = load i64, i64* %9
%37 = getelementptr inbounds double, double* %35, i64 %36
%38 = load double, double* %37
%39 = load float*, float** %5
%40 = load i64, i64* %9
%41 = getelementptr inbounds float, float* %39, i64 %40
%42 = load float, float* %41
%43 = fpext float %42 to double
%44 = fadd double %38, %43
%45 = load double*, double** %6
%46 = load i64, i64* %9
%47 = add i64 %46, 1
%48 = getelementptr inbounds double, double* %45, i64 %47
store double %44, double* %48
%49 = load double*, double** %7
%50 = load i64, i64* %9
%51 = getelementptr inbounds double, double* %49, i64 %50
%52 = load double, double* %51
%53 = load float*, float** %5
%54 = load i64, i64* %9
%55 = getelementptr inbounds float, float* %53, i64 %54
%56 = load float, float* %55
%57 = load float*, float** %5
%58 = load i64, i64* %9
%59 = getelementptr inbounds float, float* %57, i64 %58
%60 = load float, float* %59
%61 = fmul float %56, %60
%62 = fpext float %61 to double
%63 = fadd double %52, %62
%64 = load double*, double** %7
%65 = load i64, i64* %9
%66 = add i64 %65, 1
%67 = getelementptr inbounds double, double* %64, i64 %66
store double %63, double* %67
br label %68
68: ; preds = %34
%69 = load i64, i64* %9
%70 = add i64 %69, 1
store i64 %70, i64* %9
br label %30
71: ; preds = %12, %16, %20, %30
ret void
}

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