#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 */
typedef int int32_t;
typedef int int16_t;

/* Variables and functions */
int16_t fir(const int32_t *p1, const int16_t *p2, int len) {
  int32_t sum = 0;
  for (; len > 0; len--, p1++, p2--)
    sum += ((int32_t)*p1) * ((int32_t)*p2);
  return sum >> 16;
}


x86 assembly (clang, -O0):
<fir>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    1159 <fir+0x59>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    -0x10(%rbp),%rcx
imul   (%rcx),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x10(%rbp)
jmp    1116 <fir+0x16>
mov    -0x18(%rbp),%eax
sar    $0x10,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<fir>:
test   %edx,%edx
jle    131b <fir+0x21b>
lea    -0x1(%rdx),%r9d
xor    %eax,%eax
cmp    $0x7,%r9d
jb     12f1 <fir+0x1f1>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     131e <fir+0x21e>
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
lea    0x30(%rdi),%rax
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
movdqu -0x3c(%rsi,%rcx,4),%xmm8
movdqu -0x2c(%rsi,%rcx,4),%xmm10
movdqu -0x1c(%rsi,%rcx,4),%xmm6
movdqu -0xc(%rsi,%rcx,4),%xmm3
pshufd $0x1b,%xmm3,%xmm7
pshufd $0x1b,%xmm6,%xmm2
pshufd $0x4e,%xmm3,%xmm12
movdqu -0x30(%rax),%xmm4
movdqu -0x20(%rax),%xmm5
movdqu -0x10(%rax),%xmm11
movdqu (%rax),%xmm9
pshufd $0xf5,%xmm4,%xmm3
pmuludq %xmm12,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm4,%xmm7
pshufd $0xe8,%xmm7,%xmm4
punpckldq %xmm3,%xmm4
paddd  %xmm0,%xmm4
pshufd $0x4e,%xmm6,%xmm0
pshufd $0xf5,%xmm5,%xmm3
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm0
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm0,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x1b,%xmm10,%xmm0
pshufd $0x1b,%xmm8,%xmm1
pshufd $0x4e,%xmm10,%xmm3
pshufd $0xf5,%xmm11,%xmm5
pmuludq %xmm3,%xmm5
pshufd $0xe8,%xmm5,%xmm3
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm3,%xmm0
paddd  %xmm4,%xmm0
pshufd $0x4e,%xmm8,%xmm3
pshufd $0xf5,%xmm9,%xmm4
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm3
pmuludq %xmm9,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm3,%xmm1
paddd  %xmm2,%xmm1
add    $0x40,%rax
add    $0xfffffffffffffff0,%rcx
add    $0xfffffffffffffffe,%r11
jne    1150 <fir+0x50>
neg    %rcx
test   $0x1,%r10b
je     12c0 <fir+0x1c0>
lea    0x0(,%rcx,4),%r10
mov    %rsi,%rax
sub    %r10,%rax
movdqu (%rdi,%rcx,4),%xmm2
movdqu 0x10(%rdi,%rcx,4),%xmm8
movdqu -0x1c(%rax),%xmm4
movdqu -0xc(%rax),%xmm5
pshufd $0x1b,%xmm5,%xmm6
pshufd $0x1b,%xmm4,%xmm7
pshufd $0xf5,%xmm2,%xmm3
pshufd $0x4e,%xmm5,%xmm5
pmuludq %xmm3,%xmm5
pshufd $0xe8,%xmm5,%xmm3
pmuludq %xmm2,%xmm6
pshufd $0xe8,%xmm6,%xmm2
punpckldq %xmm3,%xmm2
paddd  %xmm2,%xmm0
pshufd $0xf5,%xmm8,%xmm2
pshufd $0x4e,%xmm4,%xmm3
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm2
pmuludq %xmm8,%xmm7
pshufd $0xe8,%xmm7,%xmm3
punpckldq %xmm2,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%r9
je     1317 <fir+0x217>
lea    0x0(,%r8,4),%rcx
sub    %r8d,%edx
sub    %rcx,%rsi
lea    (%rdi,%r8,4),%rdi
add    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi),%ecx
imul   (%rdi),%ecx
add    %ecx,%eax
add    $0x4,%rdi
add    $0xfffffffffffffffc,%rsi
add    $0xffffffff,%edx
cmp    $0x1,%edx
ja     1300 <fir+0x200>
sar    $0x10,%eax
ret
xor    %eax,%eax
ret
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
test   $0x1,%r10b
jne    1248 <fir+0x148>
jmp    12c0 <fir+0x1c0>

LLVM IR (-O0):
define i32 @fir(i32* %0, i32* %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i32 %2, i32* %6
store i32 0, i32* %7
br label %8
8: ; preds = %19, %3
%9 = load i32, i32* %6
%10 = icmp sgt i32 %9, 0
br i1 %10, label %11, label %26
11: ; preds = %8
%12 = load i32*, i32** %4
%13 = load i32, i32* %12
%14 = load i32*, i32** %5
%15 = load i32, i32* %14
%16 = mul nsw i32 %13, %15
%17 = load i32, i32* %7
%18 = add nsw i32 %17, %16
store i32 %18, i32* %7
br label %19
19: ; preds = %11
%20 = load i32, i32* %6
%21 = add nsw i32 %20, -1
store i32 %21, i32* %6
%22 = load i32*, i32** %4
%23 = getelementptr inbounds i32, i32* %22, i32 1
store i32* %23, i32** %4
%24 = load i32*, i32** %5
%25 = getelementptr inbounds i32, i32* %24, i32 -1
store i32* %25, i32** %5
br label %8
26: ; preds = %8
%27 = load i32, i32* %7
%28 = ashr i32 %27, 16
ret i32 %28
}

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