#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__ malloc(int);
double *autocorr(double a[], int len, int maxlag) {
  int i, k;
  double *acf = (double *)malloc(maxlag * sizeof(double));
  double term1;
  double term21;
  double term22;
  double norm;
  for (k = 0; k < maxlag; k++) {
    term1 = 0;
    term21 = 0;
    term22 = 0;
    for (i = 0; i < len - k; i++) {
      term1 += a[i] * a[i + k];
      term21 += a[i];
      term22 += a[i + k];
    }
    term1 /= i;
    term21 /= i;
    term22 /= i;
    acf[k] = term1 - term21 * term22;
  }
  norm = acf[0];
  for (k = 0; k < maxlag; k++) {
    acf[k] = acf[k] / norm;
  }
  return acf;
}


x86 assembly (clang, -O0):
<autocorr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    126c <autocorr+0x15c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    11ea <autocorr+0xda>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1167 <autocorr+0x57>
cvtsi2sdl -0x14(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x28(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    113c <autocorr+0x2c>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12b9 <autocorr+0x1a9>
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1280 <autocorr+0x170>
mov    -0x20(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<autocorr>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %edx,%r14d
mov    %esi,%r12d
mov    %rdi,%r15
lea    0x0(,%r14,8),%edi
call   1030 <malloc@plt>
test   %r14d,%r14d
jle    1327 <autocorr+0x217>
mov    %r14d,%r8d
lea    0x8(%r15),%rdx
xor    %r10d,%r10d
xor    %edi,%edi
mov    %r12d,%ebp
jmp    1184 <autocorr+0x74>
nopl   0x0(%rax,%rax,1)
xorps  %xmm3,%xmm3
cvtsi2sd %ecx,%xmm3
divsd  %xmm3,%xmm2
divsd  %xmm3,%xmm0
divsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rax,%rdi,8)
add    $0x1,%rdi
add    $0xffffffff,%ebp
add    $0x8,%r10
cmp    %r8,%rdi
je     1255 <autocorr+0x145>
xorpd  %xmm2,%xmm2
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
mov    $0x0,%ecx
cmp    %r12d,%edi
jge    1150 <autocorr+0x40>
mov    %ebp,%r9d
cmp    $0x1,%ebp
jne    11c0 <autocorr+0xb0>
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
xorpd  %xmm1,%xmm1
xorpd  %xmm2,%xmm2
jmp    1223 <autocorr+0x113>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r9d,%ecx
and    $0xfffffffe,%ecx
lea    (%rdx,%r10,1),%rsi
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
xorpd  %xmm1,%xmm1
xorpd  %xmm3,%xmm3
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rbx,8),%xmm4
movsd  (%rdx,%rbx,8),%xmm2
movsd  -0x8(%rsi,%rbx,8),%xmm5
movsd  (%rsi,%rbx,8),%xmm6
addsd  %xmm4,%xmm1
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
addsd  %xmm5,%xmm0
addsd  %xmm2,%xmm1
mulsd  %xmm6,%xmm2
addsd  %xmm4,%xmm2
addsd  %xmm6,%xmm0
add    $0x2,%rbx
movapd %xmm2,%xmm3
cmp    %rbx,%rcx
jne    11e0 <autocorr+0xd0>
mov    %ebp,%ecx
test   $0x1,%r9b
je     1150 <autocorr+0x40>
movsd  (%r15,%rbx,8),%xmm3
add    %rdi,%rbx
movsd  (%r15,%rbx,8),%xmm4
addsd  %xmm3,%xmm1
mulsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
addsd  %xmm4,%xmm0
mov    %ebp,%ecx
jmp    1150 <autocorr+0x40>
test   %r14d,%r14d
jle    1327 <autocorr+0x217>
movsd  (%rax),%xmm0
movapd %xmm0,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax)
cmp    $0x1,%r14d
je     1327 <autocorr+0x217>
lea    -0x1(%r8),%rcx
mov    $0x1,%edx
cmp    $0x2,%rcx
jb     1310 <autocorr+0x200>
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rdx),%rsi
mov    %rsi,%rbp
shr    %rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1330 <autocorr+0x220>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%edi
nopl   (%rax)
movupd (%rax,%rdi,8),%xmm2
movupd 0x10(%rax,%rdi,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rdi,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rax,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rsi
jne    12c0 <autocorr+0x1b0>
test   $0x1,%bpl
je     12fc <autocorr+0x1ec>
movupd (%rax,%rdi,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rdi,8)
cmp    %rdx,%rcx
je     1327 <autocorr+0x217>
or     $0x1,%rcx
mov    %rcx,%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1310 <autocorr+0x200>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%edi
test   $0x1,%bpl
jne    12ee <autocorr+0x1de>
jmp    12fc <autocorr+0x1ec>

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

LLVM IR (-O2):
define double* @autocorr(double* nocapture %0, i32 %1, i32 %2) {
%4 = shl i32 %2, 3
%5 = tail call i64 @malloc(i32 %4)
%6 = inttoptr i64 %5 to double*
%7 = icmp sgt i32 %2, 0
br i1 %7, label %8, label %142
8: ; preds = %3
%9 = zext i32 %2 to i64
br label %10
10: ; preds = %8, %65
%11 = phi i64 [ 0, %8 ], [ %77, %65 ]
%12 = phi i32 [ %1, %8 ], [ %78, %65 ]
%13 = zext i32 %12 to i64
%14 = trunc i64 %11 to i32
%15 = icmp slt i32 %14, %1
br i1 %15, label %16, label %65
16: ; preds = %10
%17 = and i64 %13, 1
%18 = icmp eq i32 %12, 1
br i1 %18, label %47, label %19
19: ; preds = %16
%20 = and i64 %13, 4294967294
br label %21
21: ; preds = %21, %19
%22 = phi i64 [ 0, %19 ], [ %44, %21 ]
%23 = phi double [ 0.000000e+00, %19 ], [ %43, %21 ]
%24 = phi double [ 0.000000e+00, %19 ], [ %42, %21 ]
%25 = phi double [ 0.000000e+00, %19 ], [ %41, %21 ]
%26 = phi i64 [ 0, %19 ], [ %45, %21 ]
%27 = getelementptr inbounds double, double* %0, i64 %22
%28 = load double, double* %27
%29 = add nuw nsw i64 %22, %11
%30 = getelementptr inbounds double, double* %0, i64 %29
%31 = load double, double* %30
%32 = tail call double @llvm.fmuladd.f64(double %28, double %31, double %25)
%33 = fadd double %24, %28
%34 = fadd double %23, %31
%35 = or i64 %22, 1
%36 = getelementptr inbounds double, double* %0, i64 %35
%37 = load double, double* %36
%38 = add nuw nsw i64 %35, %11
%39 = getelementptr inbounds double, double* %0, i64 %38
%40 = load double, double* %39
%41 = tail call double @llvm.fmuladd.f64(double %37, double %40, double %32)
%42 = fadd double %33, %37
%43 = fadd double %34, %40
%44 = add nuw nsw i64 %22, 2
%45 = add i64 %26, 2
%46 = icmp eq i64 %45, %20
br i1 %46, label %47, label %21
47: ; preds = %21, %16
%48 = phi double [ undef, %16 ], [ %41, %21 ]
%49 = phi double [ undef, %16 ], [ %42, %21 ]
%50 = phi double [ undef, %16 ], [ %43, %21 ]
%51 = phi i64 [ 0, %16 ], [ %44, %21 ]
%52 = phi double [ 0.000000e+00, %16 ], [ %43, %21 ]
%53 = phi double [ 0.000000e+00, %16 ], [ %42, %21 ]
%54 = phi double [ 0.000000e+00, %16 ], [ %41, %21 ]
%55 = icmp eq i64 %17, 0
br i1 %55, label %65, label %56
56: ; preds = %47
%57 = getelementptr inbounds double, double* %0, i64 %51
%58 = load double, double* %57
%59 = add nuw nsw i64 %51, %11
%60 = getelementptr inbounds double, double* %0, i64 %59
%61 = load double, double* %60
%62 = tail call double @llvm.fmuladd.f64(double %58, double %61, double %54)
%63 = fadd double %53, %58
%64 = fadd double %52, %61
br label %65
65: ; preds = %56, %47, %10
%66 = phi double [ 0.000000e+00, %10 ], [ %48, %47 ], [ %62, %56 ]
%67 = phi double [ 0.000000e+00, %10 ], [ %49, %47 ], [ %63, %56 ]
%68 = phi double [ 0.000000e+00, %10 ], [ %50, %47 ], [ %64, %56 ]
%69 = phi i32 [ 0, %10 ], [ %12, %47 ], [ %12, %56 ]
%70 = sitofp i32 %69 to double
%71 = fdiv double %66, %70
%72 = fdiv double %68, %70
%73 = fneg double %67
%74 = fdiv double %73, %70
%75 = tail call double @llvm.fmuladd.f64(double %74, double %72, double %71)
%76 = getelementptr inbounds double, double* %6, i64 %11
store double %75, double* %76
%77 = add nuw nsw i64 %11, 1
%78 = add i32 %12, -1
%79 = icmp eq i64 %77, %9
br i1 %79, label %80, label %10
80: ; preds = %65
%81 = load double, double* %6
br i1 %7, label %82, label %142
82: ; preds = %80
%83 = zext i32 %2 to i64
%84 = fdiv double %81, %81
store double %84, double* %6
%85 = icmp eq i32 %2, 1
br i1 %85, label %142, label %86
86: ; preds = %82
%87 = add nsw i64 %9, -1
%88 = icmp ult i64 %87, 2
br i1 %88, label %132, label %89
89: ; preds = %86
%90 = and i64 %87, -2
%91 = or i64 %87, 1
%92 = insertelement <2 x double> poison, double %81, i64 0
%93 = shufflevector <2 x double> %92, <2 x double> poison, <2 x i32> zeroinitializer
%94 = add nsw i64 %90, -2
%95 = lshr exact i64 %94, 1
%96 = add nuw i64 %95, 1
%97 = and i64 %96, 1
%98 = icmp eq i64 %94, 0
br i1 %98, label %121, label %99
99: ; preds = %89
%100 = and i64 %96, -2
br label %101
101: ; preds = %101, %99
%102 = phi i64 [ 0, %99 ], [ %116, %101 ]
%103 = phi i64 [ 0, %99 ], [ %117, %101 ]
%104 = or i64 %102, 1
%105 = getelementptr inbounds double, double* %6, i64 %104
%106 = bitcast double* %105 to <2 x double>*
%107 = load <2 x double>, <2 x double>* %106
%108 = fdiv <2 x double> %107, %93
%109 = bitcast double* %105 to <2 x double>*
store <2 x double> %108, <2 x double>* %109
%110 = or i64 %102, 3
%111 = getelementptr inbounds double, double* %6, i64 %110
%112 = bitcast double* %111 to <2 x double>*
%113 = load <2 x double>, <2 x double>* %112
%114 = fdiv <2 x double> %113, %93
%115 = bitcast double* %111 to <2 x double>*
store <2 x double> %114, <2 x double>* %115
%116 = add nuw i64 %102, 4
%117 = add nuw i64 %103, 2
%118 = icmp eq i64 %117, %100
br i1 %118, label %119, label %101
119: ; preds = %101
%120 = or i64 %116, 1
br label %121
121: ; preds = %119, %89
%122 = phi i64 [ 1, %89 ], [ %120, %119 ]
%123 = icmp eq i64 %97, 0
br i1 %123, label %130, label %124
124: ; preds = %121
%125 = getelementptr inbounds double, double* %6, i64 %122
%126 = bitcast double* %125 to <2 x double>*
%127 = load <2 x double>, <2 x double>* %126
%128 = fdiv <2 x double> %127, %93
%129 = bitcast double* %125 to <2 x double>*
store <2 x double> %128, <2 x double>* %129
br label %130
130: ; preds = %121, %124
%131 = icmp eq i64 %87, %90
br i1 %131, label %142, label %132
132: ; preds = %86, %130
%133 = phi i64 [ 1, %86 ], [ %91, %130 ]
br label %134
134: ; preds = %132, %134
%135 = phi i64 [ %140, %134 ], [ %133, %132 ]
%136 = getelementptr inbounds double, double* %6, i64 %135
%137 = load double, double* %136
%138 = getelementptr inbounds double, double* %6, i64 %135
%139 = fdiv double %137, %81
store double %139, double* %138
%140 = add nuw nsw i64 %135, 1
%141 = icmp eq i64 %140, %83
br i1 %141, label %142, label %134
142: ; preds = %134, %82, %130, %3, %80
ret double* %6
}