void downmix_to_mono_from_stereo(const short *src[2], short *dst, unsigned n) {
  unsigned i;
  int sum;
  for (i = 0; i < n; i++) {
    sum = *(src[0] + i);
    sum += *(src[1] + i);
    *dst =
        (short)(((sum) > (0x7FFF)) ? (0x7FFF)
                                   : (((sum) < (-0x8000)) ? (-0x8000) : (sum)));
    dst++;
  }
}


x86 assembly (clang, -O0):
<downmix_to_mono_from_stereo>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    11af <downmix_to_mono_from_stereo+0xaf>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%ecx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x18(%rbp),%ecx
movswl (%rax,%rcx,2),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x7fff,-0x1c(%rbp)
jle    1162 <downmix_to_mono_from_stereo+0x62>
mov    $0x7fff,%eax
mov    %eax,-0x20(%rbp)
jmp    1188 <downmix_to_mono_from_stereo+0x88>
cmpl   $0xffff8000,-0x1c(%rbp)
jge    117c <downmix_to_mono_from_stereo+0x7c>
mov    $0xffff8000,%eax
mov    %eax,-0x24(%rbp)
jmp    1182 <downmix_to_mono_from_stereo+0x82>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %cx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1116 <downmix_to_mono_from_stereo+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<downmix_to_mono_from_stereo>:
test   %edx,%edx
je     12d3 <downmix_to_mono_from_stereo+0x1d3>
mov    (%rdi),%rcx
mov    0x8(%rdi),%rdi
mov    %edx,%r10d
cmp    $0x10,%edx
jae    11d7 <downmix_to_mono_from_stereo+0xd7>
xor    %r8d,%r8d
mov    %r8,%r11
not    %r11
test   $0x1,%r10b
je     1156 <downmix_to_mono_from_stereo+0x56>
movzwl (%rcx,%r8,2),%eax
movzwl (%rdi,%r8,2),%r9d
lea    (%rax,%r9,1),%edx
movswl %dx,%edx
sar    $0xf,%edx
xor    $0xffff8000,%edx
add    %r9w,%ax
cmovo  %edx,%eax
mov    %ax,(%rsi)
add    $0x2,%rsi
or     $0x1,%r8
add    %r10,%r11
je     12d3 <downmix_to_mono_from_stereo+0x1d3>
sub    %r8,%r10
lea    (%rcx,%r8,2),%r9
add    $0x2,%r9
lea    (%rdi,%r8,2),%r8
add    $0x2,%r8
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzwl -0x2(%r9,%rdi,2),%eax
movzwl -0x2(%r8,%rdi,2),%ecx
lea    (%rax,%rcx,1),%edx
movswl %dx,%edx
sar    $0xf,%edx
xor    $0xffff8000,%edx
add    %cx,%ax
cmovo  %edx,%eax
mov    %ax,(%rsi,%rdi,2)
movzwl (%r9,%rdi,2),%eax
movzwl (%r8,%rdi,2),%ecx
lea    (%rax,%rcx,1),%edx
movswl %dx,%edx
sar    $0xf,%edx
xor    $0xffff8000,%edx
add    %cx,%ax
cmovo  %edx,%eax
mov    %ax,0x2(%rsi,%rdi,2)
add    $0x2,%rdi
cmp    %rdi,%r10
jne    1180 <downmix_to_mono_from_stereo+0x80>
jmp    12d3 <downmix_to_mono_from_stereo+0x1d3>
lea    (%rsi,%r10,2),%rdx
lea    (%rcx,%r10,2),%rax
lea    (%rdi,%r10,2),%r8
cmp    %rsi,%rax
seta   %r9b
cmp    %rdx,%rcx
setb   %r11b
cmp    %rsi,%r8
seta   %al
cmp    %rdx,%rdi
setb   %dl
xor    %r8d,%r8d
test   %r11b,%r9b
jne    111e <downmix_to_mono_from_stereo+0x1e>
and    %dl,%al
jne    111e <downmix_to_mono_from_stereo+0x1e>
mov    %r10d,%r8d
and    $0xfffffff0,%r8d
lea    -0x10(%r8),%rax
mov    %rax,%r9
shr    $0x4,%r9
add    $0x1,%r9
test   %rax,%rax
je     12dd <downmix_to_mono_from_stereo+0x1dd>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
nopl   0x0(%rax)
movdqu (%rcx,%rdx,2),%xmm0
movdqu 0x10(%rcx,%rdx,2),%xmm1
movdqu (%rdi,%rdx,2),%xmm2
paddsw %xmm0,%xmm2
movdqu 0x10(%rdi,%rdx,2),%xmm0
paddsw %xmm1,%xmm0
movdqu %xmm2,(%rsi,%rdx,2)
movdqu %xmm0,0x10(%rsi,%rdx,2)
movdqu 0x20(%rcx,%rdx,2),%xmm0
movdqu 0x30(%rcx,%rdx,2),%xmm1
movdqu 0x20(%rdi,%rdx,2),%xmm2
paddsw %xmm0,%xmm2
movdqu 0x30(%rdi,%rdx,2),%xmm0
paddsw %xmm1,%xmm0
movdqu %xmm2,0x20(%rsi,%rdx,2)
movdqu %xmm0,0x30(%rsi,%rdx,2)
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rax
jne    1240 <downmix_to_mono_from_stereo+0x140>
test   $0x1,%r9b
je     12ce <downmix_to_mono_from_stereo+0x1ce>
movdqu (%rcx,%rdx,2),%xmm0
movdqu 0x10(%rcx,%rdx,2),%xmm1
movdqu (%rdi,%rdx,2),%xmm2
paddsw %xmm0,%xmm2
movdqu 0x10(%rdi,%rdx,2),%xmm0
paddsw %xmm1,%xmm0
movdqu %xmm2,(%rsi,%rdx,2)
movdqu %xmm0,0x10(%rsi,%rdx,2)
cmp    %r10,%r8
jne    12d4 <downmix_to_mono_from_stereo+0x1d4>
ret
lea    (%rsi,%r8,2),%rsi
jmp    111e <downmix_to_mono_from_stereo+0x1e>
xor    %edx,%edx
test   $0x1,%r9b
jne    12a5 <downmix_to_mono_from_stereo+0x1a5>
jmp    12ce <downmix_to_mono_from_stereo+0x1ce>

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

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