#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*/ free(char *);
void C2FcopyLogVect(long size, int *A, char *B) {
  long i;
  for (i = 0; i < size; i++)
    A[i] = ((B[i]) ? 1 : 0);
  free(B);
}


x86 assembly (clang, -O0):
<C2FcopyLogVect>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    116f <C2FcopyLogVect+0x5f>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %edx,%edx
mov    $0x1,%eax
cmp    $0x0,%ecx
cmovne %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    112c <C2FcopyLogVect+0x1c>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<C2FcopyLogVect>:
mov    %rdx,%r10
test   %rdi,%rdi
jle    12ef <C2FcopyLogVect+0x1df>
cmp    $0x8,%rdi
jb     113c <C2FcopyLogVect+0x2c>
lea    (%r10,%rdi,1),%rax
cmp    %rsi,%rax
jbe    11c8 <C2FcopyLogVect+0xb8>
lea    (%rsi,%rdi,4),%rax
cmp    %r10,%rax
jbe    11c8 <C2FcopyLogVect+0xb8>
xor    %eax,%eax
mov    %rax,%r8
not    %r8
add    %rdi,%r8
mov    %rdi,%rcx
and    $0x3,%rcx
je     1167 <C2FcopyLogVect+0x57>
xor    %edx,%edx
cmpb   $0x0,(%r10,%rax,1)
setne  %dl
mov    %edx,(%rsi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    1150 <C2FcopyLogVect+0x40>
cmp    $0x3,%r8
jb     12ef <C2FcopyLogVect+0x1df>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
cmpb   $0x0,(%r10,%rax,1)
setne  %cl
mov    %ecx,(%rsi,%rax,4)
xor    %ecx,%ecx
cmpb   $0x0,0x1(%r10,%rax,1)
setne  %cl
mov    %ecx,0x4(%rsi,%rax,4)
xor    %ecx,%ecx
cmpb   $0x0,0x2(%r10,%rax,1)
setne  %cl
mov    %ecx,0x8(%rsi,%rax,4)
xor    %ecx,%ecx
cmpb   $0x0,0x3(%r10,%rax,1)
setne  %cl
mov    %ecx,0xc(%rsi,%rax,4)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1180 <C2FcopyLogVect+0x70>
jmp    12ef <C2FcopyLogVect+0x1df>
mov    %rdi,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     12f7 <C2FcopyLogVect+0x1e7>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
movdqa 0xe00(%rip),%xmm2
movd   (%r10,%rcx,1),%xmm3
movd   0x4(%r10,%rcx,1),%xmm4
pcmpeqb %xmm0,%xmm3
pxor   %xmm1,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm2,%xmm3
pcmpeqb %xmm0,%xmm4
pxor   %xmm1,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm2,%xmm4
movdqu %xmm3,(%rsi,%rcx,4)
movdqu %xmm4,0x10(%rsi,%rcx,4)
movd   0x8(%r10,%rcx,1),%xmm3
movd   0xc(%r10,%rcx,1),%xmm4
pcmpeqb %xmm0,%xmm3
pxor   %xmm1,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm2,%xmm3
pcmpeqb %xmm0,%xmm4
pxor   %xmm1,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm2,%xmm4
movdqu %xmm3,0x20(%rsi,%rcx,4)
movdqu %xmm4,0x30(%rsi,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%r9
jne    1200 <C2FcopyLogVect+0xf0>
test   $0x1,%r8b
je     12e6 <C2FcopyLogVect+0x1d6>
movd   (%r10,%rcx,1),%xmm0
movd   0x4(%r10,%rcx,1),%xmm1
pxor   %xmm2,%xmm2
pcmpeqb %xmm2,%xmm0
pcmpeqd %xmm3,%xmm3
pxor   %xmm3,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movdqa 0xd3d(%rip),%xmm4
pand   %xmm4,%xmm0
pcmpeqb %xmm2,%xmm1
pxor   %xmm3,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm4,%xmm1
movdqu %xmm0,(%rsi,%rcx,4)
movdqu %xmm1,0x10(%rsi,%rcx,4)
cmp    %rdi,%rax
jne    113e <C2FcopyLogVect+0x2e>
mov    %r10,%rdi
jmp    1030 <free@plt>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1296 <C2FcopyLogVect+0x186>
jmp    12e6 <C2FcopyLogVect+0x1d6>

LLVM IR (-O0):
define void @C2FcopyLogVect(i64 %0, i32* %1, i8* %2) {
%4 = alloca i64
%5 = alloca i32*
%6 = alloca i8*
%7 = alloca i64
store i64 %0, i64* %4
store i32* %1, i32** %5
store i8* %2, i8** %6
store i64 0, i64* %7
br label %8
8: ; preds = %24, %3
%9 = load i64, i64* %7
%10 = load i64, i64* %4
%11 = icmp slt i64 %9, %10
br i1 %11, label %12, label %27
12: ; preds = %8
%13 = load i8*, i8** %6
%14 = load i64, i64* %7
%15 = getelementptr inbounds i8, i8* %13, i64 %14
%16 = load i8, i8* %15
%17 = sext i8 %16 to i32
%18 = icmp ne i32 %17, 0
%19 = zext i1 %18 to i64
%20 = select i1 %18, i32 1, i32 0
%21 = load i32*, i32** %5
%22 = load i64, i64* %7
%23 = getelementptr inbounds i32, i32* %21, i64 %22
store i32 %20, i32* %23
br label %24
24: ; preds = %12
%25 = load i64, i64* %7
%26 = add nsw i64 %25, 1
store i64 %26, i64* %7
br label %8
27: ; preds = %8
%28 = load i8*, i8** %6
%29 = call i32 @free(i8* %28)
ret void
}

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