#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*/ bar(int);
void foo() {
  short coef[32];
  short input[100];
  short output[100];
  int i, j, k;
  int sum;
  for (i = 0; i < 100; i++) {
    sum = 0;
    for (j = 0; j < 32; j++) {
      sum += input[i + 10 - j] * coef[j];
    }
    output[i] = sum;
  }
  bar(sum);
}


x86 assembly (clang, -O0):
<foo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1f0,%rsp
movl   $0x0,-0x1e4(%rbp)
cmpl   $0x64,-0x1e4(%rbp)
jge    11c7 <foo+0xb7>
movl   $0x0,-0x1f0(%rbp)
movl   $0x0,-0x1e8(%rbp)
cmpl   $0x20,-0x1e8(%rbp)
jge    119b <foo+0x8b>
mov    -0x1e4(%rbp),%eax
add    $0xa,%eax
sub    -0x1e8(%rbp),%eax
cltq
movswl -0x110(%rbp,%rax,2),%eax
ff
movslq -0x1e8(%rbp),%rcx
movswl -0x40(%rbp,%rcx,2),%ecx
imul   %ecx,%eax
add    -0x1f0(%rbp),%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x1e8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1e8(%rbp)
jmp    1146 <foo+0x36>
mov    -0x1f0(%rbp),%eax
mov    %ax,%cx
movslq -0x1e4(%rbp),%rax
mov    %cx,-0x1e0(%rbp,%rax,2)
ff
mov    -0x1e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1e4(%rbp)
jmp    1125 <foo+0x15>
mov    -0x1f0(%rbp),%edi
call   1030 <bar@plt>
add    $0x1f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<foo>:
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
cmp    $0x6a,%rax
jne    1120 <foo+0x10>
sub    $0x88,%rsp
movq   -0x48(%rsp),%xmm0
movq   -0x78(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm0
pshuflw $0x1b,%xmm1,%xmm2
pxor   %xmm1,%xmm1
punpcklwd %xmm1,%xmm2
pmaddwd %xmm0,%xmm2
movq   -0x50(%rsp),%xmm0
movq   -0x70(%rsp,%rax,2),%xmm3
punpcklwd %xmm0,%xmm0
pshuflw $0x1b,%xmm3,%xmm3
punpcklwd %xmm1,%xmm3
pmaddwd %xmm0,%xmm3
movq   -0x58(%rsp),%xmm4
movq   -0x68(%rsp,%rax,2),%xmm0
punpcklwd %xmm4,%xmm4
pshuflw $0x1b,%xmm0,%xmm0
punpcklwd %xmm1,%xmm0
pmaddwd %xmm4,%xmm0
paddd  %xmm3,%xmm0
paddd  %xmm2,%xmm0
movq   -0x60(%rsp),%xmm2
movq   -0x60(%rsp,%rax,2),%xmm3
punpcklwd %xmm2,%xmm2
pshuflw $0x1b,%xmm3,%xmm3
punpcklwd %xmm1,%xmm3
pmaddwd %xmm2,%xmm3
movq   -0x68(%rsp),%xmm2
movq   -0x58(%rsp,%rax,2),%xmm4
punpcklwd %xmm2,%xmm2
pshuflw $0x1b,%xmm4,%xmm4
punpcklwd %xmm1,%xmm4
pmaddwd %xmm2,%xmm4
paddd  %xmm3,%xmm4
movq   -0x70(%rsp),%xmm2
movq   -0x50(%rsp,%rax,2),%xmm3
punpcklwd %xmm2,%xmm2
pshuflw $0x1b,%xmm3,%xmm3
punpcklwd %xmm1,%xmm3
pmaddwd %xmm2,%xmm3
movq   -0x78(%rsp),%xmm1
movq   -0x48(%rsp,%rax,2),%xmm2
pshuflw $0x1b,%xmm2,%xmm2
movq   -0x80(%rsp),%xmm5
punpcklwd %xmm5,%xmm1
movq   -0x40(%rsp,%rax,2),%xmm5
pshuflw $0x1b,%xmm5,%xmm5
punpcklwd %xmm5,%xmm2
pmaddwd %xmm1,%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm4,%xmm2
paddd  %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
paddd  %xmm2,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edi
add    $0x88,%rsp
jmp    1030 <bar@plt>

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

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