#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 /*<<< orphan*/ uint8_t;

/* Variables and functions */
unsigned int csum_lrc_compute(const uint8_t *in, size_t len,
                              unsigned char *rc) {
  unsigned char lrc = 0;
  while (len--)
    lrc ^= *in++;
  if (rc)
    *rc = lrc;
  return 1;
}


x86 assembly (clang, -O0):
<csum_lrc_compute>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movb   $0x0,-0x19(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x10(%rbp)
cmp    $0x0,%rax
je     114c <csum_lrc_compute+0x4c>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%ecx
movzbl -0x19(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x19(%rbp)
jmp    1114 <csum_lrc_compute+0x14>
cmpq   $0x0,-0x18(%rbp)
je     1160 <csum_lrc_compute+0x60>
mov    -0x19(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    $0x1,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<csum_lrc_compute>:
test   %rsi,%rsi
je     1112 <csum_lrc_compute+0x12>
cmp    $0x8,%rsi
jae    1119 <csum_lrc_compute+0x19>
xor    %eax,%eax
jmp    1230 <csum_lrc_compute+0x130>
xor    %eax,%eax
jmp    124c <csum_lrc_compute+0x14c>
mov    %rsi,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1259 <csum_lrc_compute+0x159>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
pxor   %xmm4,%xmm4
xor    %eax,%eax
movdqa 0xeb3(%rip),%xmm2
pxor   %xmm5,%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%rdi,%rax,4),%xmm6
movdqu 0x10(%rdi,%rax,4),%xmm3
movdqu 0x20(%rdi,%rax,4),%xmm0
movdqu 0x30(%rdi,%rax,4),%xmm1
pand   %xmm2,%xmm6
packuswb %xmm6,%xmm6
packuswb %xmm6,%xmm6
pxor   %xmm4,%xmm6
pand   %xmm2,%xmm3
packuswb %xmm3,%xmm3
packuswb %xmm3,%xmm3
pxor   %xmm5,%xmm3
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pxor   %xmm6,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pxor   %xmm3,%xmm1
add    $0x10,%rax
movdqa %xmm0,%xmm4
movdqa %xmm1,%xmm5
add    $0xfffffffffffffffe,%rcx
jne    1160 <csum_lrc_compute+0x60>
test   $0x1,%r9b
je     1202 <csum_lrc_compute+0x102>
movdqu (%rdi,%rax,4),%xmm2
movdqu 0x10(%rdi,%rax,4),%xmm3
movdqa 0xe1e(%rip),%xmm4
pand   %xmm4,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
pxor   %xmm2,%xmm0
pand   %xmm4,%xmm3
packuswb %xmm3,%xmm3
packuswb %xmm3,%xmm3
pxor   %xmm3,%xmm1
pxor   %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pxor   %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrlw  $0x8,%xmm0
pxor   %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %rsi,%r8
je     124c <csum_lrc_compute+0x14c>
and    $0x7,%esi
lea    (%rdi,%r8,4),%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    (%rdi,%rcx,4),%al
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1240 <csum_lrc_compute+0x140>
test   %rdx,%rdx
je     1253 <csum_lrc_compute+0x153>
mov    %al,(%rdx)
mov    $0x1,%eax
ret
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
test   $0x1,%r9b
jne    11cf <csum_lrc_compute+0xcf>
jmp    1202 <csum_lrc_compute+0x102>

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

LLVM IR (-O2):
define i32 @csum_lrc_compute(i32* nocapture %0, i64 %1, i8* writeonly %2) {
%4 = icmp eq i64 %1, 0
br i1 %4, label %85, label %5
5: ; preds = %3
%6 = icmp ult i64 %1, 8
br i1 %6, label %71, label %7
7: ; preds = %5
%8 = and i64 %1, -8
%9 = getelementptr i32, i32* %0, i64 %8
%10 = and i64 %1, 7
%11 = add i64 %8, -8
%12 = lshr exact i64 %11, 3
%13 = add nuw nsw i64 %12, 1
%14 = and i64 %13, 1
%15 = icmp eq i64 %11, 0
br i1 %15, label %47, label %16
16: ; preds = %7
%17 = and i64 %13, 4611686018427387902
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %44, %18 ]
%20 = phi <4 x i8> [ zeroinitializer, %16 ], [ %42, %18 ]
%21 = phi <4 x i8> [ zeroinitializer, %16 ], [ %43, %18 ]
%22 = phi i64 [ 0, %16 ], [ %45, %18 ]
%23 = getelementptr i32, i32* %0, i64 %19
%24 = bitcast i32* %23 to <4 x i32>*
%25 = load <4 x i32>, <4 x i32>* %24
%26 = getelementptr i32, i32* %23, i64 4
%27 = bitcast i32* %26 to <4 x i32>*
%28 = load <4 x i32>, <4 x i32>* %27
%29 = trunc <4 x i32> %25 to <4 x i8>
%30 = trunc <4 x i32> %28 to <4 x i8>
%31 = xor <4 x i8> %20, %29
%32 = xor <4 x i8> %21, %30
%33 = or i64 %19, 8
%34 = getelementptr i32, i32* %0, i64 %33
%35 = bitcast i32* %34 to <4 x i32>*
%36 = load <4 x i32>, <4 x i32>* %35
%37 = getelementptr i32, i32* %34, i64 4
%38 = bitcast i32* %37 to <4 x i32>*
%39 = load <4 x i32>, <4 x i32>* %38
%40 = trunc <4 x i32> %36 to <4 x i8>
%41 = trunc <4 x i32> %39 to <4 x i8>
%42 = xor <4 x i8> %31, %40
%43 = xor <4 x i8> %32, %41
%44 = add nuw i64 %19, 16
%45 = add i64 %22, 2
%46 = icmp eq i64 %45, %17
br i1 %46, label %47, label %18
47: ; preds = %18, %7
%48 = phi <4 x i8> [ undef, %7 ], [ %42, %18 ]
%49 = phi <4 x i8> [ undef, %7 ], [ %43, %18 ]
%50 = phi i64 [ 0, %7 ], [ %44, %18 ]
%51 = phi <4 x i8> [ zeroinitializer, %7 ], [ %42, %18 ]
%52 = phi <4 x i8> [ zeroinitializer, %7 ], [ %43, %18 ]
%53 = icmp eq i64 %14, 0
br i1 %53, label %65, label %54
54: ; preds = %47
%55 = getelementptr i32, i32* %0, i64 %50
%56 = bitcast i32* %55 to <4 x i32>*
%57 = load <4 x i32>, <4 x i32>* %56
%58 = getelementptr i32, i32* %55, i64 4
%59 = bitcast i32* %58 to <4 x i32>*
%60 = load <4 x i32>, <4 x i32>* %59
%61 = trunc <4 x i32> %57 to <4 x i8>
%62 = trunc <4 x i32> %60 to <4 x i8>
%63 = xor <4 x i8> %51, %61
%64 = xor <4 x i8> %52, %62
br label %65
65: ; preds = %47, %54
%66 = phi <4 x i8> [ %48, %47 ], [ %63, %54 ]
%67 = phi <4 x i8> [ %49, %47 ], [ %64, %54 ]
%68 = xor <4 x i8> %67, %66
%69 = call i8 @llvm.vector.reduce.xor.v4i8(<4 x i8> %68)
%70 = icmp eq i64 %8, %1
br i1 %70, label %85, label %71
71: ; preds = %5, %65
%72 = phi i8 [ 0, %5 ], [ %69, %65 ]
%73 = phi i32* [ %0, %5 ], [ %9, %65 ]
%74 = phi i64 [ %1, %5 ], [ %10, %65 ]
br label %75
75: ; preds = %71, %75
%76 = phi i8 [ %83, %75 ], [ %72, %71 ]
%77 = phi i32* [ %80, %75 ], [ %73, %71 ]
%78 = phi i64 [ %79, %75 ], [ %74, %71 ]
%79 = add i64 %78, -1
%80 = getelementptr inbounds i32, i32* %77, i64 1
%81 = load i32, i32* %77
%82 = trunc i32 %81 to i8
%83 = xor i8 %76, %82
%84 = icmp eq i64 %79, 0
br i1 %84, label %85, label %75
85: ; preds = %75, %65, %3
%86 = phi i8 [ 0, %3 ], [ %69, %65 ], [ %83, %75 ]
%87 = icmp eq i8* %2, null
br i1 %87, label %89, label %88
88: ; preds = %85
store i8 %86, i8* %2
br label %89
89: ; preds = %88, %85
ret i32 1
}