#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 */
scalar_t__ weed_malloc(int);
unsigned char *mix(unsigned char *a, unsigned char *b, int pcpy) {
  unsigned char *mixed = (unsigned char *)weed_malloc(pcpy);
  register int i;
  for (i = 0; i < pcpy; i++) {
    mixed[i] = (*(a + i) + *(b + i)) >> 1;
  }
  return mixed;
}


x86 assembly (clang, -O0):
<mix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%edi
call   1030 <weed_malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    117a <mix+0x6a>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
sar    $0x1,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1136 <mix+0x26>
mov    -0x20(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mix>:
push   %rbp
push   %r14
push   %rbx
mov    %edx,%ebp
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %edx,%edi
call   1030 <weed_malloc@plt>
test   %ebp,%ebp
jle    12ce <mix+0x1be>
mov    %ebp,%ecx
cmp    $0x8,%ebp
jae    1139 <mix+0x29>
xor    %edx,%edx
jmp    1273 <mix+0x163>
lea    (%rax,%rcx,1),%rdx
lea    (%rbx,%rcx,1),%rsi
cmp    %rax,%rsi
seta   %r8b
lea    (%r14,%rcx,1),%rsi
cmp    %rbx,%rdx
seta   %r9b
cmp    %rax,%rsi
seta   %sil
cmp    %r14,%rdx
seta   %dil
xor    %edx,%edx
test   %r9b,%r8b
jne    1273 <mix+0x163>
and    %dil,%sil
jne    1273 <mix+0x163>
cmp    $0x20,%ebp
jae    1181 <mix+0x71>
xor    %edx,%edx
jmp    122a <mix+0x11a>
mov    %ecx,%edx
and    $0xffffffe0,%edx
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movdqu (%rbx,%rsi,1),%xmm1
movdqu 0x10(%rbx,%rsi,1),%xmm2
movdqa %xmm1,%xmm3
punpckhbw %xmm0,%xmm3
punpcklbw %xmm0,%xmm1
movdqa %xmm2,%xmm4
punpckhbw %xmm0,%xmm4
punpcklbw %xmm0,%xmm2
movdqu (%r14,%rsi,1),%xmm5
movdqu 0x10(%r14,%rsi,1),%xmm6
movdqa %xmm5,%xmm7
punpckhbw %xmm0,%xmm7
paddw  %xmm3,%xmm7
punpcklbw %xmm0,%xmm5
paddw  %xmm1,%xmm5
movdqa %xmm6,%xmm1
punpckhbw %xmm0,%xmm1
paddw  %xmm4,%xmm1
punpcklbw %xmm0,%xmm6
paddw  %xmm2,%xmm6
psrlw  $0x1,%xmm7
psrlw  $0x1,%xmm5
packuswb %xmm7,%xmm5
psrlw  $0x1,%xmm1
psrlw  $0x1,%xmm6
packuswb %xmm1,%xmm6
movdqu %xmm5,(%rax,%rsi,1)
movdqu %xmm6,0x10(%rax,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    1190 <mix+0x80>
cmp    %rcx,%rdx
je     12ce <mix+0x1be>
test   $0x18,%cl
je     1273 <mix+0x163>
mov    %rdx,%rsi
mov    %ecx,%edx
and    $0xfffffff8,%edx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movq   (%rbx,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm1
movq   (%r14,%rsi,1),%xmm2
punpcklbw %xmm0,%xmm2
paddw  %xmm1,%xmm2
psrlw  $0x1,%xmm2
packuswb %xmm2,%xmm2
movq   %xmm2,(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1240 <mix+0x130>
cmp    %rcx,%rdx
je     12ce <mix+0x1be>
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
je     1293 <mix+0x183>
movzbl (%rbx,%rdx,1),%edi
movzbl (%r14,%rdx,1),%ebp
add    %edi,%ebp
shr    %ebp
mov    %bpl,(%rax,%rdx,1)
or     $0x1,%rdx
add    %rcx,%rsi
je     12ce <mix+0x1be>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rdx,1),%esi
movzbl (%r14,%rdx,1),%edi
add    %esi,%edi
shr    %edi
mov    %dil,(%rax,%rdx,1)
movzbl 0x1(%rbx,%rdx,1),%esi
movzbl 0x1(%r14,%rdx,1),%edi
add    %esi,%edi
shr    %edi
mov    %dil,0x1(%rax,%rdx,1)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    12a0 <mix+0x190>
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define i8* @mix(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%9 = load i32, i32* %6
%10 = call i64 @weed_malloc(i32 %9)
%11 = inttoptr i64 %10 to i8*
store i8* %11, i8** %7
store i32 0, i32* %8
br label %12
12: ; preds = %36, %3
%13 = load i32, i32* %8
%14 = load i32, i32* %6
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %39
16: ; preds = %12
%17 = load i8*, i8** %4
%18 = load i32, i32* %8
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i8, i8* %17, i64 %19
%21 = load i8, i8* %20
%22 = zext i8 %21 to i32
%23 = load i8*, i8** %5
%24 = load i32, i32* %8
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
%27 = load i8, i8* %26
%28 = zext i8 %27 to i32
%29 = add nsw i32 %22, %28
%30 = ashr i32 %29, 1
%31 = trunc i32 %30 to i8
%32 = load i8*, i8** %7
%33 = load i32, i32* %8
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i8, i8* %32, i64 %34
store i8 %31, i8* %35
br label %36
36: ; preds = %16
%37 = load i32, i32* %8
%38 = add nsw i32 %37, 1
store i32 %38, i32* %8
br label %12
39: ; preds = %12
%40 = load i8*, i8** %7
ret i8* %40
}

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