void auto_correl2(long *w, int n, long *r) {
  int i, k;
  long long temp, temp2;
  for (k = 0; k <= 10; k++, n--) {
    temp = 0;
    for (i = 0; i < n; i++) {
      temp2 = w[i];
      temp += temp2 * w[i + k];
    }
    r[k] = (long)(temp >> 20);
  }
}


x86 assembly (clang, -O0):
<auto_correl2>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jg     11a2 <auto_correl2+0xa2>
movq   $0x0,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1177 <auto_correl2+0x77>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    -0x20(%rbp),%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,8),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112f <auto_correl2+0x2f>
mov    -0x28(%rbp),%rdx
sar    $0x14,%rdx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    1116 <auto_correl2+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<auto_correl2>:
push   %r14
push   %rbx
lea    0x30(%rdi),%rax
xor    %r8d,%r8d
mov    %rdi,%r10
xor    %r9d,%r9d
jmp    1147 <auto_correl2+0x47>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %esi,%esi
sar    $0x14,%rsi
mov    %rsi,(%rdx,%r9,8)
add    $0x1,%r9
add    $0xffffffff,%r14d
add    $0x8,%r8
add    $0x8,%r10
mov    %r14d,%esi
cmp    $0xb,%r9
je     138a <auto_correl2+0x28a>
mov    %esi,%r14d
test   %esi,%esi
jle    1120 <auto_correl2+0x20>
cmp    $0x4,%r14d
jae    1160 <auto_correl2+0x60>
xor    %ecx,%ecx
xor    %esi,%esi
jmp    1370 <auto_correl2+0x270>
nopl   (%rax)
and    $0xfffffffc,%esi
add    $0xfffffffffffffffc,%rsi
mov    %rsi,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rsi,%rsi
je     12be <auto_correl2+0x1be>
mov    %r14d,%ebx
and    $0xfffffffc,%ebx
add    $0xfffffffffffffffc,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%rax,%r8,1),%rcx
pxor   %xmm11,%xmm11
xor    %esi,%esi
pxor   %xmm9,%xmm9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rcx,%rsi,8),%xmm3
movdqu -0x20(%rcx,%rsi,8),%xmm2
movdqu -0x10(%rcx,%rsi,8),%xmm0
movdqu (%rcx,%rsi,8),%xmm1
movdqa %xmm3,%xmm4
psrlq  $0x20,%xmm4
movdqu -0x30(%rax,%rsi,8),%xmm7
movdqu -0x20(%rax,%rsi,8),%xmm6
movdqu -0x10(%rax,%rsi,8),%xmm10
movdqu (%rax,%rsi,8),%xmm8
pmuludq %xmm7,%xmm4
movdqa %xmm7,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm3,%xmm5
paddq  %xmm4,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm7,%xmm3
paddq  %xmm11,%xmm3
paddq  %xmm5,%xmm3
movdqa %xmm2,%xmm4
psrlq  $0x20,%xmm4
pmuludq %xmm6,%xmm4
movdqa %xmm6,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm2,%xmm5
paddq  %xmm4,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm6,%xmm2
paddq  %xmm9,%xmm2
paddq  %xmm5,%xmm2
movdqa %xmm0,%xmm4
psrlq  $0x20,%xmm4
pmuludq %xmm10,%xmm4
movdqa %xmm10,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm0,%xmm5
paddq  %xmm4,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm10,%xmm0
paddq  %xmm5,%xmm0
paddq  %xmm3,%xmm0
movdqa %xmm1,%xmm3
psrlq  $0x20,%xmm3
pmuludq %xmm8,%xmm3
movdqa %xmm8,%xmm4
psrlq  $0x20,%xmm4
pmuludq %xmm1,%xmm4
paddq  %xmm3,%xmm4
psllq  $0x20,%xmm4
pmuludq %xmm8,%xmm1
paddq  %xmm4,%xmm1
paddq  %xmm2,%xmm1
add    $0x8,%rsi
movdqa %xmm0,%xmm11
movdqa %xmm1,%xmm9
add    $0xfffffffffffffffe,%rbx
jne    11b0 <auto_correl2+0xb0>
jmp    12c8 <auto_correl2+0x1c8>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
mov    %r14d,%ecx
and    $0xfffffffc,%ecx
test   $0x1,%r11b
je     134b <auto_correl2+0x24b>
movdqu (%rdi,%rsi,8),%xmm4
movdqu 0x10(%rdi,%rsi,8),%xmm2
add    %r9,%rsi
movdqu (%rdi,%rsi,8),%xmm5
movdqu 0x10(%rdi,%rsi,8),%xmm3
movdqa %xmm4,%xmm6
psrlq  $0x20,%xmm6
pmuludq %xmm5,%xmm6
movdqa %xmm5,%xmm7
psrlq  $0x20,%xmm7
pmuludq %xmm4,%xmm7
paddq  %xmm6,%xmm7
psllq  $0x20,%xmm7
pmuludq %xmm4,%xmm5
paddq  %xmm7,%xmm5
paddq  %xmm5,%xmm0
movdqa %xmm2,%xmm4
psrlq  $0x20,%xmm4
pmuludq %xmm3,%xmm4
movdqa %xmm3,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm2,%xmm5
paddq  %xmm4,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm2,%xmm3
paddq  %xmm5,%xmm3
paddq  %xmm3,%xmm1
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%rsi
cmp    %r14,%rcx
je     1122 <auto_correl2+0x22>
cs nopw 0x0(%rax,%rax,1)
mov    (%r10,%rcx,8),%rbx
imul   (%rdi,%rcx,8),%rbx
add    %rbx,%rsi
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1370 <auto_correl2+0x270>
jmp    1122 <auto_correl2+0x22>
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @auto_correl2(i64* %0, i32 %1, i64* %2) {
%4 = alloca i64*
%5 = alloca i32
%6 = alloca i64*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i64
%10 = alloca i64
store i64* %0, i64** %4
store i32 %1, i32* %5
store i64* %2, i64** %6
store i32 0, i32* %8
br label %11
11: ; preds = %46, %3
%12 = load i32, i32* %8
%13 = icmp sle i32 %12, 10
br i1 %13, label %14, label %51
14: ; preds = %11
store i64 0, i64* %9
store i32 0, i32* %7
br label %15
15: ; preds = %36, %14
%16 = load i32, i32* %7
%17 = load i32, i32* %5
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %39
19: ; preds = %15
%20 = load i64*, i64** %4
%21 = load i32, i32* %7
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i64, i64* %20, i64 %22
%24 = load i64, i64* %23
store i64 %24, i64* %10
%25 = load i64, i64* %10
%26 = load i64*, i64** %4
%27 = load i32, i32* %7
%28 = load i32, i32* %8
%29 = add nsw i32 %27, %28
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i64, i64* %26, i64 %30
%32 = load i64, i64* %31
%33 = mul nsw i64 %25, %32
%34 = load i64, i64* %9
%35 = add nsw i64 %34, %33
store i64 %35, i64* %9
br label %36
36: ; preds = %19
%37 = load i32, i32* %7
%38 = add nsw i32 %37, 1
store i32 %38, i32* %7
br label %15
39: ; preds = %15
%40 = load i64, i64* %9
%41 = ashr i64 %40, 20
%42 = load i64*, i64** %6
%43 = load i32, i32* %8
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i64, i64* %42, i64 %44
store i64 %41, i64* %45
br label %46
46: ; preds = %39
%47 = load i32, i32* %8
%48 = add nsw i32 %47, 1
store i32 %48, i32* %8
%49 = load i32, i32* %5
%50 = add nsw i32 %49, -1
store i32 %50, i32* %5
br label %11
51: ; preds = %11
ret void
}

LLVM IR (-O2):
define void @auto_correl2(i64* nocapture %0, i32 %1, i64* nocapture writeonly %2) {
br label %4
4: ; preds = %3, %112
%5 = phi i64 [ 0, %3 ], [ %116, %112 ]
%6 = phi i32 [ %1, %3 ], [ %117, %112 ]
%7 = and i32 %6, -4
%8 = zext i32 %7 to i64
%9 = add nsw i64 %8, -4
%10 = lshr exact i64 %9, 2
%11 = add nuw nsw i64 %10, 1
%12 = zext i32 %6 to i64
%13 = icmp sgt i32 %6, 0
br i1 %13, label %14, label %112
14: ; preds = %4
%15 = zext i32 %6 to i64
%16 = icmp ult i32 %6, 4
br i1 %16, label %97, label %17
17: ; preds = %14
%18 = and i64 %12, 4294967292
%19 = and i64 %11, 1
%20 = icmp eq i64 %9, 0
br i1 %20, label %66, label %21
21: ; preds = %17
%22 = and i64 %11, 9223372036854775806
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %63, %23 ]
%25 = phi <2 x i64> [ zeroinitializer, %21 ], [ %61, %23 ]
%26 = phi <2 x i64> [ zeroinitializer, %21 ], [ %62, %23 ]
%27 = phi i64 [ 0, %21 ], [ %64, %23 ]
%28 = getelementptr inbounds i64, i64* %0, i64 %24
%29 = bitcast i64* %28 to <2 x i64>*
%30 = load <2 x i64>, <2 x i64>* %29
%31 = getelementptr inbounds i64, i64* %28, i64 2
%32 = bitcast i64* %31 to <2 x i64>*
%33 = load <2 x i64>, <2 x i64>* %32
%34 = add nuw nsw i64 %24, %5
%35 = getelementptr inbounds i64, i64* %0, i64 %34
%36 = bitcast i64* %35 to <2 x i64>*
%37 = load <2 x i64>, <2 x i64>* %36
%38 = getelementptr inbounds i64, i64* %35, i64 2
%39 = bitcast i64* %38 to <2 x i64>*
%40 = load <2 x i64>, <2 x i64>* %39
%41 = mul nsw <2 x i64> %37, %30
%42 = mul nsw <2 x i64> %40, %33
%43 = add <2 x i64> %41, %25
%44 = add <2 x i64> %42, %26
%45 = or i64 %24, 4
%46 = getelementptr inbounds i64, i64* %0, i64 %45
%47 = bitcast i64* %46 to <2 x i64>*
%48 = load <2 x i64>, <2 x i64>* %47
%49 = getelementptr inbounds i64, i64* %46, i64 2
%50 = bitcast i64* %49 to <2 x i64>*
%51 = load <2 x i64>, <2 x i64>* %50
%52 = add nuw nsw i64 %45, %5
%53 = getelementptr inbounds i64, i64* %0, i64 %52
%54 = bitcast i64* %53 to <2 x i64>*
%55 = load <2 x i64>, <2 x i64>* %54
%56 = getelementptr inbounds i64, i64* %53, i64 2
%57 = bitcast i64* %56 to <2 x i64>*
%58 = load <2 x i64>, <2 x i64>* %57
%59 = mul nsw <2 x i64> %55, %48
%60 = mul nsw <2 x i64> %58, %51
%61 = add <2 x i64> %59, %43
%62 = add <2 x i64> %60, %44
%63 = add nuw i64 %24, 8
%64 = add i64 %27, 2
%65 = icmp eq i64 %64, %22
br i1 %65, label %66, label %23
66: ; preds = %23, %17
%67 = phi <2 x i64> [ undef, %17 ], [ %61, %23 ]
%68 = phi <2 x i64> [ undef, %17 ], [ %62, %23 ]
%69 = phi i64 [ 0, %17 ], [ %63, %23 ]
%70 = phi <2 x i64> [ zeroinitializer, %17 ], [ %61, %23 ]
%71 = phi <2 x i64> [ zeroinitializer, %17 ], [ %62, %23 ]
%72 = icmp eq i64 %19, 0
br i1 %72, label %91, label %73
73: ; preds = %66
%74 = getelementptr inbounds i64, i64* %0, i64 %69
%75 = bitcast i64* %74 to <2 x i64>*
%76 = load <2 x i64>, <2 x i64>* %75
%77 = getelementptr inbounds i64, i64* %74, i64 2
%78 = bitcast i64* %77 to <2 x i64>*
%79 = load <2 x i64>, <2 x i64>* %78
%80 = add nuw nsw i64 %69, %5
%81 = getelementptr inbounds i64, i64* %0, i64 %80
%82 = bitcast i64* %81 to <2 x i64>*
%83 = load <2 x i64>, <2 x i64>* %82
%84 = getelementptr inbounds i64, i64* %81, i64 2
%85 = bitcast i64* %84 to <2 x i64>*
%86 = load <2 x i64>, <2 x i64>* %85
%87 = mul nsw <2 x i64> %83, %76
%88 = mul nsw <2 x i64> %86, %79
%89 = add <2 x i64> %87, %70
%90 = add <2 x i64> %88, %71
br label %91
91: ; preds = %66, %73
%92 = phi <2 x i64> [ %67, %66 ], [ %89, %73 ]
%93 = phi <2 x i64> [ %68, %66 ], [ %90, %73 ]
%94 = add <2 x i64> %93, %92
%95 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %94)
%96 = icmp eq i64 %18, %12
br i1 %96, label %112, label %97
97: ; preds = %14, %91
%98 = phi i64 [ 0, %14 ], [ %18, %91 ]
%99 = phi i64 [ 0, %14 ], [ %95, %91 ]
br label %100
100: ; preds = %97, %100
%101 = phi i64 [ %110, %100 ], [ %98, %97 ]
%102 = phi i64 [ %109, %100 ], [ %99, %97 ]
%103 = getelementptr inbounds i64, i64* %0, i64 %101
%104 = load i64, i64* %103
%105 = add nuw nsw i64 %101, %5
%106 = getelementptr inbounds i64, i64* %0, i64 %105
%107 = load i64, i64* %106
%108 = mul nsw i64 %107, %104
%109 = add nsw i64 %108, %102
%110 = add nuw nsw i64 %101, 1
%111 = icmp eq i64 %110, %15
br i1 %111, label %112, label %100
112: ; preds = %100, %91, %4
%113 = phi i64 [ 0, %4 ], [ %95, %91 ], [ %109, %100 ]
%114 = ashr i64 %113, 20
%115 = getelementptr inbounds i64, i64* %2, i64 %5
store i64 %114, i64* %115
%116 = add nuw nsw i64 %5, 1
%117 = add nsw i32 %6, -1
%118 = icmp eq i64 %116, 11
br i1 %118, label %119, label %4
119: ; preds = %112
ret void
}