#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 uint8_t;

/* Variables and functions */
void pixel_avg(uint8_t *dst, int i_dst_stride, uint8_t *src1, int i_src1_stride,
               uint8_t *src2, int i_src2_stride, int i_width, int i_height) {
  int x, y;
  for (y = 0; y < i_height; y++) {
    for (x = 0; x < i_width; x++) {
      dst[x] = (src1[x] + src2[x] + 1) >> 1;
    }
    dst += i_dst_stride;
    src1 += i_src1_stride;
    src2 += i_src2_stride;
  }
}


x86 assembly (clang, -O0):
<pixel_avg>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    11c8 <pixel_avg+0xc8>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    117b <pixel_avg+0x7b>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
add    (%rax,%rcx,4),%edx
add    $0x1,%edx
sar    $0x1,%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    113a <pixel_avg+0x3a>
mov    -0xc(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1127 <pixel_avg+0x27>
pop    %rbp
ret

x86 assembly (clang, -O2):
<pixel_avg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8,-0x48(%rsp)
mov    %rdx,-0x50(%rsp)
mov    %rdi,-0x58(%rsp)
mov    0x40(%rsp),%ebp
test   %ebp,%ebp
jle    13f8 <pixel_avg+0x2f8>
mov    0x38(%rsp),%edx
movslq %esi,%r10
movslq %ecx,%rsi
movslq %r9d,%rdi
mov    %edx,%ecx
mov    %ecx,%ebx
and    $0xfffffff8,%ebx
mov    %rbx,-0x28(%rsp)
add    $0xfffffffffffffff8,%rbx
mov    %rbx,-0x30(%rsp)
mov    %rbx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,%rbx
mov    %rax,-0x38(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x40(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,-0x8(%rsp)
mov    %rsi,-0x18(%rsp)
lea    0x0(,%rsi,4),%r8
mov    %rdi,-0x20(%rsp)
lea    0x0(,%rdi,4),%r12
mov    %r10,-0x10(%rsp)
lea    0x0(,%r10,4),%r9
xor    %r15d,%r15d
pcmpeqd %xmm0,%xmm0
mov    -0x58(%rsp),%rdi
mov    -0x48(%rsp),%r11
mov    -0x50(%rsp),%r10
jmp    11c6 <pixel_avg+0xc6>
nopl   (%rax)
add    %r9,%rdi
add    %r8,%r10
add    %r12,%r11
add    $0x1,%r15
cmp    %ebp,%r15d
je     13f8 <pixel_avg+0x2f8>
test   %edx,%edx
jle    11b0 <pixel_avg+0xb0>
cmp    $0x8,%edx
jae    11e0 <pixel_avg+0xe0>
xor    %esi,%esi
jmp    1380 <pixel_avg+0x280>
cs nopw 0x0(%rax,%rax,1)
mov    %ebp,%r13d
mov    %r15,%rax
imul   -0x10(%rsp),%rax
add    %rcx,%rax
mov    %r15,%rsi
imul   -0x18(%rsp),%rsi
add    %rcx,%rsi
mov    %r15,%rbx
imul   -0x20(%rsp),%rbx
add    %rcx,%rbx
mov    -0x58(%rsp),%rbp
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
mov    -0x50(%rsp),%rbp
lea    0x0(,%rsi,4),%rsi
add    %rbp,%rsi
mov    -0x48(%rsp),%rbp
lea    0x0(,%rbx,4),%rbx
add    %rbp,%rbx
cmp    %rsi,%rdi
setb   %sil
cmp    %rax,%r10
setb   %r14b
cmp    %rbx,%rdi
setb   %bl
cmp    %rax,%r11
setb   %al
test   %r14b,%sil
jne    136e <pixel_avg+0x26e>
mov    $0x0,%esi
and    %al,%bl
mov    %r13d,%ebp
jne    1380 <pixel_avg+0x280>
cmpq   $0x0,-0x30(%rsp)
je     13e5 <pixel_avg+0x2e5>
mov    -0x40(%rsp),%r13
xor    %r14d,%r14d
xchg   %ax,%ax
movdqu (%r10,%r14,4),%xmm1
movdqu 0x10(%r10,%r14,4),%xmm2
movdqu (%r11,%r14,4),%xmm3
paddd  %xmm1,%xmm3
movdqu 0x10(%r11,%r14,4),%xmm1
paddd  %xmm2,%xmm1
psubd  %xmm0,%xmm3
psubd  %xmm0,%xmm1
psrad  $0x1,%xmm3
psrad  $0x1,%xmm1
movdqu %xmm3,(%rdi,%r14,4)
movdqu %xmm1,0x10(%rdi,%r14,4)
movdqu 0x20(%r10,%r14,4),%xmm1
movdqu 0x30(%r10,%r14,4),%xmm2
movdqu 0x20(%r11,%r14,4),%xmm3
paddd  %xmm1,%xmm3
movdqu 0x30(%r11,%r14,4),%xmm1
paddd  %xmm2,%xmm1
psubd  %xmm0,%xmm3
psubd  %xmm0,%xmm1
psrad  $0x1,%xmm3
psrad  $0x1,%xmm1
movdqu %xmm3,0x20(%rdi,%r14,4)
movdqu %xmm1,0x30(%rdi,%r14,4)
add    $0x10,%r14
add    $0xfffffffffffffffe,%r13
jne    1280 <pixel_avg+0x180>
testb  $0x1,-0x38(%rsp)
je     135b <pixel_avg+0x25b>
movdqu (%r10,%r14,4),%xmm1
movdqu 0x10(%r10,%r14,4),%xmm2
movdqu (%r11,%r14,4),%xmm3
paddd  %xmm1,%xmm3
movdqu 0x10(%r11,%r14,4),%xmm1
paddd  %xmm2,%xmm1
psubd  %xmm0,%xmm3
psubd  %xmm0,%xmm1
psrad  $0x1,%xmm3
psrad  $0x1,%xmm1
movdqu %xmm3,(%rdi,%r14,4)
movdqu %xmm1,0x10(%rdi,%r14,4)
mov    -0x28(%rsp),%rax
mov    %rax,%rsi
cmp    %rcx,%rax
je     11b0 <pixel_avg+0xb0>
jmp    1380 <pixel_avg+0x280>
xor    %esi,%esi
mov    %r13d,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rsi,%rbx
test   $0x1,%cl
je     13a1 <pixel_avg+0x2a1>
mov    (%r10,%rsi,4),%eax
mov    (%r11,%rsi,4),%ebx
add    %ebx,%eax
add    $0x1,%eax
sar    %eax
mov    %eax,(%rdi,%rsi,4)
mov    %rsi,%rbx
or     $0x1,%rbx
not    %rsi
cmp    -0x8(%rsp),%rsi
je     11b0 <pixel_avg+0xb0>
nop
mov    (%r10,%rbx,4),%eax
mov    (%r11,%rbx,4),%esi
add    %esi,%eax
add    $0x1,%eax
sar    %eax
mov    %eax,(%rdi,%rbx,4)
mov    0x4(%r10,%rbx,4),%eax
mov    0x4(%r11,%rbx,4),%esi
add    %esi,%eax
add    $0x1,%eax
sar    %eax
mov    %eax,0x4(%rdi,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    13b0 <pixel_avg+0x2b0>
jmp    11b0 <pixel_avg+0xb0>
xor    %r14d,%r14d
testb  $0x1,-0x38(%rsp)
jne    131a <pixel_avg+0x21a>
jmp    135b <pixel_avg+0x25b>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @pixel_avg(i32* nocapture writeonly %0, i32 %1, i32* nocapture %2, i32 %3, i32* nocapture %4, i32 %5, i32 %6, i32 %7) {
%9 = icmp sgt i32 %7, 0
br i1 %9, label %10, label %176
10: ; preds = %8
%11 = icmp sgt i32 %6, 0
%12 = sext i32 %1 to i64
%13 = sext i32 %3 to i64
%14 = sext i32 %5 to i64
%15 = zext i32 %6 to i64
%16 = and i64 %15, 4294967288
%17 = add nsw i64 %16, -8
%18 = lshr exact i64 %17, 3
%19 = add nuw nsw i64 %18, 1
%20 = icmp ult i32 %6, 8
%21 = and i64 %15, 4294967288
%22 = and i64 %19, 1
%23 = icmp eq i64 %17, 0
%24 = and i64 %19, 4611686018427387902
%25 = icmp eq i64 %22, 0
%26 = icmp eq i64 %21, %15
%27 = and i64 %15, 1
%28 = icmp eq i64 %27, 0
%29 = sub nsw i64 0, %15
br label %30
30: ; preds = %10, %169
%31 = phi i64 [ 0, %10 ], [ %175, %169 ]
%32 = phi i32 [ 0, %10 ], [ %173, %169 ]
%33 = phi i32* [ %0, %10 ], [ %170, %169 ]
%34 = phi i32* [ %2, %10 ], [ %171, %169 ]
%35 = phi i32* [ %4, %10 ], [ %172, %169 ]
%36 = mul i64 %31, %12
%37 = add i64 %36, %15
%38 = getelementptr i32, i32* %0, i64 %37
%39 = mul i64 %31, %13
%40 = add i64 %39, %15
%41 = getelementptr i32, i32* %2, i64 %40
%42 = mul i64 %31, %14
%43 = add i64 %42, %15
%44 = getelementptr i32, i32* %4, i64 %43
br i1 %11, label %45, label %169
45: ; preds = %30
br i1 %20, label %132, label %46
46: ; preds = %45
%47 = icmp ult i32* %33, %41
%48 = icmp ult i32* %34, %38
%49 = and i1 %47, %48
%50 = icmp ult i32* %33, %44
%51 = icmp ult i32* %35, %38
%52 = and i1 %50, %51
%53 = or i1 %49, %52
br i1 %53, label %132, label %54
54: ; preds = %46
br i1 %23, label %106, label %55
55: ; preds = %54, %55
%56 = phi i64 [ %103, %55 ], [ 0, %54 ]
%57 = phi i64 [ %104, %55 ], [ 0, %54 ]
%58 = getelementptr inbounds i32, i32* %34, i64 %56
%59 = bitcast i32* %58 to <4 x i32>*
%60 = load <4 x i32>, <4 x i32>* %59
%61 = getelementptr inbounds i32, i32* %58, i64 4
%62 = bitcast i32* %61 to <4 x i32>*
%63 = load <4 x i32>, <4 x i32>* %62
%64 = getelementptr inbounds i32, i32* %35, i64 %56
%65 = bitcast i32* %64 to <4 x i32>*
%66 = load <4 x i32>, <4 x i32>* %65
%67 = getelementptr inbounds i32, i32* %64, i64 4
%68 = bitcast i32* %67 to <4 x i32>*
%69 = load <4 x i32>, <4 x i32>* %68
%70 = add <4 x i32> %60, <i32 1, i32 1, i32 1, i32 1>
%71 = add <4 x i32> %63, <i32 1, i32 1, i32 1, i32 1>
%72 = add <4 x i32> %70, %66
%73 = add <4 x i32> %71, %69
%74 = ashr <4 x i32> %72, <i32 1, i32 1, i32 1, i32 1>
%75 = ashr <4 x i32> %73, <i32 1, i32 1, i32 1, i32 1>
%76 = getelementptr inbounds i32, i32* %33, i64 %56
%77 = bitcast i32* %76 to <4 x i32>*
store <4 x i32> %74, <4 x i32>* %77
%78 = getelementptr inbounds i32, i32* %76, i64 4
%79 = bitcast i32* %78 to <4 x i32>*
store <4 x i32> %75, <4 x i32>* %79
%80 = or i64 %56, 8
%81 = getelementptr inbounds i32, i32* %34, i64 %80
%82 = bitcast i32* %81 to <4 x i32>*
%83 = load <4 x i32>, <4 x i32>* %82
%84 = getelementptr inbounds i32, i32* %81, i64 4
%85 = bitcast i32* %84 to <4 x i32>*
%86 = load <4 x i32>, <4 x i32>* %85
%87 = getelementptr inbounds i32, i32* %35, i64 %80
%88 = bitcast i32* %87 to <4 x i32>*
%89 = load <4 x i32>, <4 x i32>* %88
%90 = getelementptr inbounds i32, i32* %87, i64 4
%91 = bitcast i32* %90 to <4 x i32>*
%92 = load <4 x i32>, <4 x i32>* %91
%93 = add <4 x i32> %83, <i32 1, i32 1, i32 1, i32 1>
%94 = add <4 x i32> %86, <i32 1, i32 1, i32 1, i32 1>
%95 = add <4 x i32> %93, %89
%96 = add <4 x i32> %94, %92
%97 = ashr <4 x i32> %95, <i32 1, i32 1, i32 1, i32 1>
%98 = ashr <4 x i32> %96, <i32 1, i32 1, i32 1, i32 1>
%99 = getelementptr inbounds i32, i32* %33, i64 %80
%100 = bitcast i32* %99 to <4 x i32>*
store <4 x i32> %97, <4 x i32>* %100
%101 = getelementptr inbounds i32, i32* %99, i64 4
%102 = bitcast i32* %101 to <4 x i32>*
store <4 x i32> %98, <4 x i32>* %102
%103 = add nuw i64 %56, 16
%104 = add i64 %57, 2
%105 = icmp eq i64 %104, %24
br i1 %105, label %106, label %55
106: ; preds = %55, %54
%107 = phi i64 [ 0, %54 ], [ %103, %55 ]
br i1 %25, label %131, label %108
108: ; preds = %106
%109 = getelementptr inbounds i32, i32* %34, i64 %107
%110 = bitcast i32* %109 to <4 x i32>*
%111 = load <4 x i32>, <4 x i32>* %110
%112 = getelementptr inbounds i32, i32* %109, i64 4
%113 = bitcast i32* %112 to <4 x i32>*
%114 = load <4 x i32>, <4 x i32>* %113
%115 = getelementptr inbounds i32, i32* %35, i64 %107
%116 = bitcast i32* %115 to <4 x i32>*
%117 = load <4 x i32>, <4 x i32>* %116
%118 = getelementptr inbounds i32, i32* %115, i64 4
%119 = bitcast i32* %118 to <4 x i32>*
%120 = load <4 x i32>, <4 x i32>* %119
%121 = add <4 x i32> %111, <i32 1, i32 1, i32 1, i32 1>
%122 = add <4 x i32> %114, <i32 1, i32 1, i32 1, i32 1>
%123 = add <4 x i32> %121, %117
%124 = add <4 x i32> %122, %120
%125 = ashr <4 x i32> %123, <i32 1, i32 1, i32 1, i32 1>
%126 = ashr <4 x i32> %124, <i32 1, i32 1, i32 1, i32 1>
%127 = getelementptr inbounds i32, i32* %33, i64 %107
%128 = bitcast i32* %127 to <4 x i32>*
store <4 x i32> %125, <4 x i32>* %128
%129 = getelementptr inbounds i32, i32* %127, i64 4
%130 = bitcast i32* %129 to <4 x i32>*
store <4 x i32> %126, <4 x i32>* %130
br label %131
131: ; preds = %106, %108
br i1 %26, label %169, label %132
132: ; preds = %46, %45, %131
%133 = phi i64 [ 0, %46 ], [ 0, %45 ], [ %21, %131 ]
%134 = xor i64 %133, -1
br i1 %28, label %145, label %135
135: ; preds = %132
%136 = getelementptr inbounds i32, i32* %34, i64 %133
%137 = load i32, i32* %136
%138 = getelementptr inbounds i32, i32* %35, i64 %133
%139 = load i32, i32* %138
%140 = add i32 %137, 1
%141 = add i32 %140, %139
%142 = ashr i32 %141, 1
%143 = getelementptr inbounds i32, i32* %33, i64 %133
store i32 %142, i32* %143
%144 = or i64 %133, 1
br label %145
145: ; preds = %135, %132
%146 = phi i64 [ %133, %132 ], [ %144, %135 ]
%147 = icmp eq i64 %134, %29
br i1 %147, label %169, label %148
148: ; preds = %145, %148
%149 = phi i64 [ %167, %148 ], [ %146, %145 ]
%150 = getelementptr inbounds i32, i32* %34, i64 %149
%151 = load i32, i32* %150
%152 = getelementptr inbounds i32, i32* %35, i64 %149
%153 = load i32, i32* %152
%154 = add i32 %151, 1
%155 = add i32 %154, %153
%156 = ashr i32 %155, 1
%157 = getelementptr inbounds i32, i32* %33, i64 %149
store i32 %156, i32* %157
%158 = add nuw nsw i64 %149, 1
%159 = getelementptr inbounds i32, i32* %34, i64 %158
%160 = load i32, i32* %159
%161 = getelementptr inbounds i32, i32* %35, i64 %158
%162 = load i32, i32* %161
%163 = add i32 %160, 1
%164 = add i32 %163, %162
%165 = ashr i32 %164, 1
%166 = getelementptr inbounds i32, i32* %33, i64 %158
store i32 %165, i32* %166
%167 = add nuw nsw i64 %149, 2
%168 = icmp eq i64 %167, %15
br i1 %168, label %169, label %148
169: ; preds = %145, %148, %131, %30
%170 = getelementptr inbounds i32, i32* %33, i64 %12
%171 = getelementptr inbounds i32, i32* %34, i64 %13
%172 = getelementptr inbounds i32, i32* %35, i64 %14
%173 = add nuw nsw i32 %32, 1
%174 = icmp eq i32 %173, %7
%175 = add i64 %31, 1
br i1 %174, label %176, label %30
176: ; preds = %169, %8
ret void
}