#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*/ memset(unsigned char *, int /*<<< orphan*/, int);
void redupe_gf_poly_add(const unsigned char *p, unsigned p_sz,
                        const unsigned char *q, unsigned q_sz, unsigned char *r,
                        unsigned *r_sz) {
  *r_sz = p_sz > q_sz ? p_sz : q_sz;
  memset(r, 0, sizeof(unsigned char) * *r_sz);
  const unsigned p_diff = *r_sz - p_sz;
  const unsigned q_diff = *r_sz - q_sz;
  for (unsigned i = 0; i < p_sz; ++i) {
    r[i + p_diff] = p[i];
  }
  for (unsigned i = 0; i < q_sz; ++i) {
    r[i + q_diff] ^= q[i];
  }
}


x86 assembly (clang, -O0):
<redupe_gf_poly_add>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jbe    1145 <redupe_gf_poly_add+0x35>
mov    -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    114b <redupe_gf_poly_add+0x3b>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
shl    $0x0,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    11bd <redupe_gf_poly_add+0xad>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    118a <redupe_gf_poly_add+0x7a>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    11fe <redupe_gf_poly_add+0xee>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
movzbl (%rax,%rcx,1),%esi
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11c4 <redupe_gf_poly_add+0xb4>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<redupe_gf_poly_add>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r9,%r13
mov    %r8,%r15
mov    %rdx,%r14
mov    %esi,%r12d
mov    %rdi,%rbp
cmp    %ecx,%esi
mov    %ecx,0x4(%rsp)
mov    %ecx,%edx
cmova  %esi,%edx
mov    %edx,(%r9)
mov    %r8,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x0(%r13),%r10d
test   %r12d,%r12d
je     11f4 <redupe_gf_poly_add+0xe4>
mov    %r12d,%ecx
cmp    $0x8,%r12d
jae    1273 <redupe_gf_poly_add+0x163>
xor    %edx,%edx
mov    %rdx,%r8
not    %r8
add    %rcx,%r8
mov    %rcx,%rdi
and    $0x3,%rdi
je     1196 <redupe_gf_poly_add+0x86>
mov    %r10d,%eax
sub    %r12d,%eax
cs nopw 0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%rdx,1),%ebx
lea    (%rax,%rdx,1),%esi
mov    %bl,(%r15,%rsi,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1180 <redupe_gf_poly_add+0x70>
cmp    $0x3,%r8
jb     11f4 <redupe_gf_poly_add+0xe4>
mov    %r10d,%esi
sub    %r12d,%esi
add    $0x3,%rbp
cs nopw 0x0(%rax,%rax,1)
movzbl -0x3(%rbp,%rdx,1),%eax
lea    (%rdx,%rsi,1),%rdi
mov    %edi,%ebx
mov    %al,(%r15,%rbx,1)
movzbl -0x2(%rbp,%rdx,1),%eax
lea    0x1(%rdi),%ebx
mov    %al,(%r15,%rbx,1)
movzbl -0x1(%rbp,%rdx,1),%eax
lea    0x2(%rdi),%ebx
mov    %al,(%r15,%rbx,1)
movzbl 0x0(%rbp,%rdx,1),%eax
add    $0x3,%edi
mov    %al,(%r15,%rdi,1)
add    $0xfffffffffffffffc,%rcx
add    $0x4,%rsi
add    $0x4,%rbp
cmp    %rcx,%rdx
jne    11b0 <redupe_gf_poly_add+0xa0>
mov    0x4(%rsp),%ebx
test   %ebx,%ebx
je     1264 <redupe_gf_poly_add+0x154>
mov    %r10d,%r9d
sub    %ebx,%r9d
mov    %ebx,%ecx
cmp    $0x8,%ebx
jae    12c3 <redupe_gf_poly_add+0x1b3>
xor    %esi,%esi
mov    %rsi,%rax
not    %rax
test   $0x1,%cl
je     1229 <redupe_gf_poly_add+0x119>
mov    (%r14,%rsi,1),%dl
add    %esi,%r9d
xor    %dl,(%r15,%r9,1)
or     $0x1,%rsi
add    %rcx,%rax
je     1264 <redupe_gf_poly_add+0x154>
sub    %rsi,%rcx
add    %esi,%r10d
sub    %ebx,%r10d
lea    (%rsi,%r14,1),%rdx
add    $0x1,%rdx
nop
movzbl -0x1(%rdx),%eax
mov    %r10d,%esi
xor    %al,(%r15,%rsi,1)
movzbl (%rdx),%eax
lea    0x1(%r10),%esi
xor    %al,(%r15,%rsi,1)
add    $0x2,%r10d
add    $0x2,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1240 <redupe_gf_poly_add+0x130>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rcx),%rax
mov    %r10d,%esi
not    %esi
add    %r12d,%esi
xor    %edx,%edx
cmp    %eax,%esi
jb     115e <redupe_gf_poly_add+0x4e>
shr    $0x20,%rax
jne    115e <redupe_gf_poly_add+0x4e>
mov    %r10d,%r9d
sub    %r12d,%r9d
lea    (%rcx,%r9,1),%rax
add    %r15,%rax
cmp    %rbp,%rax
jbe    12b6 <redupe_gf_poly_add+0x1a6>
lea    (%rcx,%rbp,1),%rax
lea    (%r15,%r9,1),%rdx
cmp    %rax,%rdx
jb     115c <redupe_gf_poly_add+0x4c>
cmp    $0x20,%r12d
jae    130b <redupe_gf_poly_add+0x1fb>
xor    %edx,%edx
jmp    14a4 <redupe_gf_poly_add+0x394>
lea    -0x1(%rcx),%rax
mov    %r10d,%edx
not    %edx
add    %ebx,%edx
xor    %esi,%esi
cmp    %eax,%edx
jb     120f <redupe_gf_poly_add+0xff>
shr    $0x20,%rax
jne    120f <redupe_gf_poly_add+0xff>
lea    (%rcx,%r9,1),%rax
add    %r15,%rax
cmp    %r14,%rax
jbe    12ff <redupe_gf_poly_add+0x1ef>
lea    (%r14,%rcx,1),%rax
lea    (%r15,%r9,1),%rdx
cmp    %rax,%rdx
jb     120d <redupe_gf_poly_add+0xfd>
cmp    $0x20,%ebx
jae    1337 <redupe_gf_poly_add+0x227>
xor    %esi,%esi
jmp    1519 <redupe_gf_poly_add+0x409>
mov    %ecx,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rax
mov    %rax,%r11
shr    $0x5,%r11
add    $0x1,%r11
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x60,%rax
jae    13d6 <redupe_gf_poly_add+0x2c6>
xor    %edi,%edi
jmp    144d <redupe_gf_poly_add+0x33d>
mov    %ecx,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rax
mov    %rax,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rax,%rax
je     14d4 <redupe_gf_poly_add+0x3c4>
movabs $0xffffffffffffffc,%rdi
ff ff 0f
or     $0x2,%rdi
and    %r8,%rdi
xor    %ebp,%ebp
mov    %r9d,%edx
nopw   0x0(%rax,%rax,1)
movups (%r14,%rbp,1),%xmm0
movups 0x10(%r14,%rbp,1),%xmm1
mov    %edx,%eax
movups (%r15,%rax,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%r15,%rax,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%r15,%rax,1)
movups %xmm0,0x10(%r15,%rax,1)
movups 0x20(%r14,%rbp,1),%xmm0
movups 0x30(%r14,%rbp,1),%xmm1
lea    0x20(%rdx),%eax
movups (%r15,%rax,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%r15,%rax,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%r15,%rax,1)
movups %xmm0,0x10(%r15,%rax,1)
add    $0x40,%rbp
add    $0x40,%edx
add    $0xfffffffffffffffe,%rdi
jne    1370 <redupe_gf_poly_add+0x260>
jmp    14d6 <redupe_gf_poly_add+0x3c6>
and    $0xfffffffffffffffc,%r11
xor    %edi,%edi
nopl   0x0(%rax)
movups 0x0(%rbp,%rdi,1),%xmm0
movups 0x10(%rbp,%rdi,1),%xmm1
lea    (%r9,%rdi,1),%rax
mov    %eax,%esi
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
movups 0x20(%rbp,%rdi,1),%xmm0
movups 0x30(%rbp,%rdi,1),%xmm1
lea    0x20(%rax),%esi
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
movups 0x40(%rbp,%rdi,1),%xmm0
movups 0x50(%rbp,%rdi,1),%xmm1
lea    0x40(%rax),%esi
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
movups 0x60(%rbp,%rdi,1),%xmm0
movups 0x70(%rbp,%rdi,1),%xmm1
add    $0x60,%eax
movups %xmm0,(%r15,%rax,1)
movups %xmm1,0x10(%r15,%rax,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%r11
jne    13e0 <redupe_gf_poly_add+0x2d0>
test   %r8,%r8
je     1492 <redupe_gf_poly_add+0x382>
lea    (%rdi,%rbp,1),%r11
add    $0x10,%r11
add    %r10d,%edi
sub    %r12d,%edi
shl    $0x5,%r8
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
lea    (%rdi,%rax,1),%esi
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    1470 <redupe_gf_poly_add+0x360>
cmp    %rcx,%rdx
je     11f4 <redupe_gf_poly_add+0xe4>
test   $0x18,%cl
je     115e <redupe_gf_poly_add+0x4e>
mov    %rdx,%rax
mov    %ecx,%edx
and    $0xfffffff8,%edx
nopl   0x0(%rax)
mov    0x0(%rbp,%rax,1),%rsi
lea    (%r9,%rax,1),%edi
mov    %rsi,(%r15,%rdi,1)
add    $0x8,%rax
cmp    %rax,%rdx
jne    14b0 <redupe_gf_poly_add+0x3a0>
cmp    %rcx,%rdx
jne    115e <redupe_gf_poly_add+0x4e>
jmp    11f4 <redupe_gf_poly_add+0xe4>
xor    %ebp,%ebp
test   $0x1,%r8b
je     1507 <redupe_gf_poly_add+0x3f7>
movups (%r14,%rbp,1),%xmm0
movups 0x10(%r14,%rbp,1),%xmm1
lea    (%r9,%rbp,1),%eax
movups (%r15,%rax,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%r15,%rax,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%r15,%rax,1)
movups %xmm0,0x10(%r15,%rax,1)
cmp    %rcx,%rsi
je     1264 <redupe_gf_poly_add+0x154>
test   $0x18,%cl
je     120f <redupe_gf_poly_add+0xff>
mov    %rsi,%rax
mov    %ecx,%esi
and    $0xfffffff8,%esi
mov    %r10d,%edx
sub    %ebx,%edx
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%rax,1),%rdi
lea    (%rdx,%rax,1),%ebp
xor    %rdi,(%r15,%rbp,1)
add    $0x8,%rax
cmp    %rax,%rsi
jne    1530 <redupe_gf_poly_add+0x420>
cmp    %rcx,%rsi
jne    120f <redupe_gf_poly_add+0xff>
jmp    1264 <redupe_gf_poly_add+0x154>

LLVM IR (-O0):
define void @redupe_gf_poly_add(i8* %0, i32 %1, i8* %2, i32 %3, i8* %4, i32* %5) {
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i32*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store i8* %0, i8** %7
store i32 %1, i32* %8
store i8* %2, i8** %9
store i32 %3, i32* %10
store i8* %4, i8** %11
store i32* %5, i32** %12
%17 = load i32, i32* %8
%18 = load i32, i32* %10
%19 = icmp ugt i32 %17, %18
br i1 %19, label %20, label %22
20: ; preds = %6
%21 = load i32, i32* %8
br label %24
22: ; preds = %6
%23 = load i32, i32* %10
br label %24
24: ; preds = %22, %20
%25 = phi i32 [ %21, %20 ], [ %23, %22 ]
%26 = load i32*, i32** %12
store i32 %25, i32* %26
%27 = load i8*, i8** %11
%28 = load i32*, i32** %12
%29 = load i32, i32* %28
%30 = zext i32 %29 to i64
%31 = mul i64 1, %30
%32 = trunc i64 %31 to i32
%33 = call i32 @memset(i8* %27, i32 0, i32 %32)
%34 = load i32*, i32** %12
%35 = load i32, i32* %34
%36 = load i32, i32* %8
%37 = sub i32 %35, %36
store i32 %37, i32* %13
%38 = load i32*, i32** %12
%39 = load i32, i32* %38
%40 = load i32, i32* %10
%41 = sub i32 %39, %40
store i32 %41, i32* %14
store i32 0, i32* %15
br label %42
42: ; preds = %58, %24
%43 = load i32, i32* %15
%44 = load i32, i32* %8
%45 = icmp ult i32 %43, %44
br i1 %45, label %46, label %61
46: ; preds = %42
%47 = load i8*, i8** %7
%48 = load i32, i32* %15
%49 = zext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %47, i64 %49
%51 = load i8, i8* %50
%52 = load i8*, i8** %11
%53 = load i32, i32* %15
%54 = load i32, i32* %13
%55 = add i32 %53, %54
%56 = zext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %52, i64 %56
store i8 %51, i8* %57
br label %58
58: ; preds = %46
%59 = load i32, i32* %15
%60 = add i32 %59, 1
store i32 %60, i32* %15
br label %42
61: ; preds = %42
store i32 0, i32* %16
br label %62
62: ; preds = %83, %61
%63 = load i32, i32* %16
%64 = load i32, i32* %10
%65 = icmp ult i32 %63, %64
br i1 %65, label %66, label %86
66: ; preds = %62
%67 = load i8*, i8** %9
%68 = load i32, i32* %16
%69 = zext i32 %68 to i64
%70 = getelementptr inbounds i8, i8* %67, i64 %69
%71 = load i8, i8* %70
%72 = zext i8 %71 to i32
%73 = load i8*, i8** %11
%74 = load i32, i32* %16
%75 = load i32, i32* %14
%76 = add i32 %74, %75
%77 = zext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %73, i64 %77
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = xor i32 %80, %72
%82 = trunc i32 %81 to i8
store i8 %82, i8* %78
br label %83
83: ; preds = %66
%84 = load i32, i32* %16
%85 = add i32 %84, 1
store i32 %85, i32* %16
br label %62
86: ; preds = %62
ret void
}

LLVM IR (-O2):
define void @redupe_gf_poly_add(i8* nocapture %0, i32 %1, i8* nocapture %2, i32 %3, i8* %4, i32* nocapture %5) {
%7 = icmp ugt i32 %1, %3
%8 = select i1 %7, i32 %1, i32 %3
store i32 %8, i32* %5
%9 = tail call i32 @memset(i8* %4, i32 0, i32 %8)
%10 = load i32, i32* %5
%11 = sub i32 %10, %1
%12 = sub i32 %10, %3
%13 = icmp eq i32 %1, 0
br i1 %13, label %172, label %14
14: ; preds = %6
%15 = zext i32 %1 to i64
%16 = icmp ult i32 %1, 8
br i1 %16, label %151, label %17
17: ; preds = %14
%18 = add nsw i64 %15, -1
%19 = trunc i64 %18 to i32
%20 = xor i32 %10, -1
%21 = add i32 %20, %1
%22 = icmp ult i32 %21, %19
%23 = icmp ugt i64 %18, 4294967295
%24 = or i1 %22, %23
br i1 %24, label %151, label %25
25: ; preds = %17
%26 = getelementptr i8, i8* %0, i64 %15
%27 = sub i32 %10, %1
%28 = zext i32 %27 to i64
%29 = getelementptr i8, i8* %4, i64 %28
%30 = add nuw nsw i64 %15, %28
%31 = getelementptr i8, i8* %4, i64 %30
%32 = icmp ugt i8* %31, %0
%33 = icmp ult i8* %29, %26
%34 = and i1 %32, %33
br i1 %34, label %151, label %35
35: ; preds = %25
%36 = icmp ult i32 %1, 32
br i1 %36, label %134, label %37
37: ; preds = %35
%38 = and i64 %15, 4294967264
%39 = add nsw i64 %38, -32
%40 = lshr exact i64 %39, 5
%41 = add nuw nsw i64 %40, 1
%42 = and i64 %41, 3
%43 = icmp ult i64 %39, 96
br i1 %43, label %107, label %44
44: ; preds = %37
%45 = and i64 %41, 1152921504606846972
br label %46
46: ; preds = %46, %44
%47 = phi i64 [ 0, %44 ], [ %104, %46 ]
%48 = phi i64 [ 0, %44 ], [ %105, %46 ]
%49 = trunc i64 %47 to i32
%50 = getelementptr inbounds i8, i8* %0, i64 %47
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = getelementptr inbounds i8, i8* %50, i64 16
%54 = bitcast i8* %53 to <16 x i8>*
%55 = load <16 x i8>, <16 x i8>* %54
%56 = add i32 %11, %49
%57 = zext i32 %56 to i64
%58 = getelementptr inbounds i8, i8* %4, i64 %57
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %52, <16 x i8>* %59
%60 = getelementptr inbounds i8, i8* %58, i64 16
%61 = bitcast i8* %60 to <16 x i8>*
store <16 x i8> %55, <16 x i8>* %61
%62 = or i64 %47, 32
%63 = trunc i64 %62 to i32
%64 = getelementptr inbounds i8, i8* %0, i64 %62
%65 = bitcast i8* %64 to <16 x i8>*
%66 = load <16 x i8>, <16 x i8>* %65
%67 = getelementptr inbounds i8, i8* %64, i64 16
%68 = bitcast i8* %67 to <16 x i8>*
%69 = load <16 x i8>, <16 x i8>* %68
%70 = add i32 %11, %63
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %4, i64 %71
%73 = bitcast i8* %72 to <16 x i8>*
store <16 x i8> %66, <16 x i8>* %73
%74 = getelementptr inbounds i8, i8* %72, i64 16
%75 = bitcast i8* %74 to <16 x i8>*
store <16 x i8> %69, <16 x i8>* %75
%76 = or i64 %47, 64
%77 = trunc i64 %76 to i32
%78 = getelementptr inbounds i8, i8* %0, i64 %76
%79 = bitcast i8* %78 to <16 x i8>*
%80 = load <16 x i8>, <16 x i8>* %79
%81 = getelementptr inbounds i8, i8* %78, i64 16
%82 = bitcast i8* %81 to <16 x i8>*
%83 = load <16 x i8>, <16 x i8>* %82
%84 = add i32 %11, %77
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %4, i64 %85
%87 = bitcast i8* %86 to <16 x i8>*
store <16 x i8> %80, <16 x i8>* %87
%88 = getelementptr inbounds i8, i8* %86, i64 16
%89 = bitcast i8* %88 to <16 x i8>*
store <16 x i8> %83, <16 x i8>* %89
%90 = or i64 %47, 96
%91 = trunc i64 %90 to i32
%92 = getelementptr inbounds i8, i8* %0, i64 %90
%93 = bitcast i8* %92 to <16 x i8>*
%94 = load <16 x i8>, <16 x i8>* %93
%95 = getelementptr inbounds i8, i8* %92, i64 16
%96 = bitcast i8* %95 to <16 x i8>*
%97 = load <16 x i8>, <16 x i8>* %96
%98 = add i32 %11, %91
%99 = zext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %4, i64 %99
%101 = bitcast i8* %100 to <16 x i8>*
store <16 x i8> %94, <16 x i8>* %101
%102 = getelementptr inbounds i8, i8* %100, i64 16
%103 = bitcast i8* %102 to <16 x i8>*
store <16 x i8> %97, <16 x i8>* %103
%104 = add nuw i64 %47, 128
%105 = add i64 %48, 4
%106 = icmp eq i64 %105, %45
br i1 %106, label %107, label %46
107: ; preds = %46, %37
%108 = phi i64 [ 0, %37 ], [ %104, %46 ]
%109 = icmp eq i64 %42, 0
br i1 %109, label %129, label %110
110: ; preds = %107, %110
%111 = phi i64 [ %126, %110 ], [ %108, %107 ]
%112 = phi i64 [ %127, %110 ], [ 0, %107 ]
%113 = trunc i64 %111 to i32
%114 = getelementptr inbounds i8, i8* %0, i64 %111
%115 = bitcast i8* %114 to <16 x i8>*
%116 = load <16 x i8>, <16 x i8>* %115
%117 = getelementptr inbounds i8, i8* %114, i64 16
%118 = bitcast i8* %117 to <16 x i8>*
%119 = load <16 x i8>, <16 x i8>* %118
%120 = add i32 %11, %113
%121 = zext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %4, i64 %121
%123 = bitcast i8* %122 to <16 x i8>*
store <16 x i8> %116, <16 x i8>* %123
%124 = getelementptr inbounds i8, i8* %122, i64 16
%125 = bitcast i8* %124 to <16 x i8>*
store <16 x i8> %119, <16 x i8>* %125
%126 = add nuw i64 %111, 32
%127 = add i64 %112, 1
%128 = icmp eq i64 %127, %42
br i1 %128, label %129, label %110
129: ; preds = %110, %107
%130 = icmp eq i64 %38, %15
br i1 %130, label %172, label %131
131: ; preds = %129
%132 = and i64 %15, 24
%133 = icmp eq i64 %132, 0
br i1 %133, label %151, label %134
134: ; preds = %35, %131
%135 = phi i64 [ %38, %131 ], [ 0, %35 ]
%136 = and i64 %15, 4294967288
br label %137
137: ; preds = %137, %134
%138 = phi i64 [ %135, %134 ], [ %147, %137 ]
%139 = trunc i64 %138 to i32
%140 = getelementptr inbounds i8, i8* %0, i64 %138
%141 = bitcast i8* %140 to <8 x i8>*
%142 = load <8 x i8>, <8 x i8>* %141
%143 = add i32 %11, %139
%144 = zext i32 %143 to i64
%145 = getelementptr inbounds i8, i8* %4, i64 %144
%146 = bitcast i8* %145 to <8 x i8>*
store <8 x i8> %142, <8 x i8>* %146
%147 = add nuw i64 %138, 8
%148 = icmp eq i64 %147, %136
br i1 %148, label %149, label %137
149: ; preds = %137
%150 = icmp eq i64 %136, %15
br i1 %150, label %172, label %151
151: ; preds = %25, %17, %14, %131, %149
%152 = phi i64 [ 0, %14 ], [ 0, %25 ], [ 0, %17 ], [ %38, %131 ], [ %136, %149 ]
%153 = xor i64 %152, -1
%154 = add nsw i64 %153, %15
%155 = and i64 %15, 3
%156 = icmp eq i64 %155, 0
br i1 %156, label %169, label %157
157: ; preds = %151, %157
%158 = phi i64 [ %166, %157 ], [ %152, %151 ]
%159 = phi i64 [ %167, %157 ], [ 0, %151 ]
%160 = getelementptr inbounds i8, i8* %0, i64 %158
%161 = load i8, i8* %160
%162 = trunc i64 %158 to i32
%163 = add i32 %11, %162
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds i8, i8* %4, i64 %164
store i8 %161, i8* %165
%166 = add nuw nsw i64 %158, 1
%167 = add i64 %159, 1
%168 = icmp eq i64 %167, %155
br i1 %168, label %169, label %157
169: ; preds = %157, %151
%170 = phi i64 [ %152, %151 ], [ %166, %157 ]
%171 = icmp ult i64 %154, 3
br i1 %171, label %172, label %318
172: ; preds = %169, %318, %129, %149, %6
%173 = icmp eq i32 %3, 0
br i1 %173, label %349, label %174
174: ; preds = %172
%175 = zext i32 %3 to i64
%176 = icmp ult i32 %3, 8
br i1 %176, label %299, label %177
177: ; preds = %174
%178 = add nsw i64 %175, -1
%179 = trunc i64 %178 to i32
%180 = xor i32 %10, -1
%181 = add i32 %180, %3
%182 = icmp ult i32 %181, %179
%183 = icmp ugt i64 %178, 4294967295
%184 = or i1 %182, %183
br i1 %184, label %299, label %185
185: ; preds = %177
%186 = getelementptr i8, i8* %2, i64 %175
%187 = sub i32 %10, %3
%188 = zext i32 %187 to i64
%189 = getelementptr i8, i8* %4, i64 %188
%190 = add nuw nsw i64 %175, %188
%191 = getelementptr i8, i8* %4, i64 %190
%192 = icmp ugt i8* %191, %2
%193 = icmp ult i8* %189, %186
%194 = and i1 %192, %193
br i1 %194, label %299, label %195
195: ; preds = %185
%196 = icmp ult i32 %3, 32
br i1 %196, label %279, label %197
197: ; preds = %195
%198 = and i64 %175, 4294967264
%199 = add nsw i64 %198, -32
%200 = lshr exact i64 %199, 5
%201 = add nuw nsw i64 %200, 1
%202 = and i64 %201, 1
%203 = icmp eq i64 %199, 0
br i1 %203, label %251, label %204
204: ; preds = %197
%205 = and i64 %201, 1152921504606846974
br label %206
206: ; preds = %206, %204
%207 = phi i64 [ 0, %204 ], [ %248, %206 ]
%208 = phi i64 [ 0, %204 ], [ %249, %206 ]
%209 = trunc i64 %207 to i32
%210 = getelementptr inbounds i8, i8* %2, i64 %207
%211 = bitcast i8* %210 to <16 x i8>*
%212 = load <16 x i8>, <16 x i8>* %211
%213 = getelementptr inbounds i8, i8* %210, i64 16
%214 = bitcast i8* %213 to <16 x i8>*
%215 = load <16 x i8>, <16 x i8>* %214
%216 = add i32 %12, %209
%217 = zext i32 %216 to i64
%218 = getelementptr inbounds i8, i8* %4, i64 %217
%219 = bitcast i8* %218 to <16 x i8>*
%220 = load <16 x i8>, <16 x i8>* %219
%221 = getelementptr inbounds i8, i8* %218, i64 16
%222 = bitcast i8* %221 to <16 x i8>*
%223 = load <16 x i8>, <16 x i8>* %222
%224 = xor <16 x i8> %220, %212
%225 = xor <16 x i8> %223, %215
%226 = bitcast i8* %218 to <16 x i8>*
store <16 x i8> %224, <16 x i8>* %226
%227 = bitcast i8* %221 to <16 x i8>*
store <16 x i8> %225, <16 x i8>* %227
%228 = or i64 %207, 32
%229 = trunc i64 %228 to i32
%230 = getelementptr inbounds i8, i8* %2, i64 %228
%231 = bitcast i8* %230 to <16 x i8>*
%232 = load <16 x i8>, <16 x i8>* %231
%233 = getelementptr inbounds i8, i8* %230, i64 16
%234 = bitcast i8* %233 to <16 x i8>*
%235 = load <16 x i8>, <16 x i8>* %234
%236 = add i32 %12, %229
%237 = zext i32 %236 to i64
%238 = getelementptr inbounds i8, i8* %4, i64 %237
%239 = bitcast i8* %238 to <16 x i8>*
%240 = load <16 x i8>, <16 x i8>* %239
%241 = getelementptr inbounds i8, i8* %238, i64 16
%242 = bitcast i8* %241 to <16 x i8>*
%243 = load <16 x i8>, <16 x i8>* %242
%244 = xor <16 x i8> %240, %232
%245 = xor <16 x i8> %243, %235
%246 = bitcast i8* %238 to <16 x i8>*
store <16 x i8> %244, <16 x i8>* %246
%247 = bitcast i8* %241 to <16 x i8>*
store <16 x i8> %245, <16 x i8>* %247
%248 = add nuw i64 %207, 64
%249 = add i64 %208, 2
%250 = icmp eq i64 %249, %205
br i1 %250, label %251, label %206
251: ; preds = %206, %197
%252 = phi i64 [ 0, %197 ], [ %248, %206 ]
%253 = icmp eq i64 %202, 0
br i1 %253, label %274, label %254
254: ; preds = %251
%255 = trunc i64 %252 to i32
%256 = getelementptr inbounds i8, i8* %2, i64 %252
%257 = bitcast i8* %256 to <16 x i8>*
%258 = load <16 x i8>, <16 x i8>* %257
%259 = getelementptr inbounds i8, i8* %256, i64 16
%260 = bitcast i8* %259 to <16 x i8>*
%261 = load <16 x i8>, <16 x i8>* %260
%262 = add i32 %12, %255
%263 = zext i32 %262 to i64
%264 = getelementptr inbounds i8, i8* %4, i64 %263
%265 = bitcast i8* %264 to <16 x i8>*
%266 = load <16 x i8>, <16 x i8>* %265
%267 = getelementptr inbounds i8, i8* %264, i64 16
%268 = bitcast i8* %267 to <16 x i8>*
%269 = load <16 x i8>, <16 x i8>* %268
%270 = xor <16 x i8> %266, %258
%271 = xor <16 x i8> %269, %261
%272 = bitcast i8* %264 to <16 x i8>*
store <16 x i8> %270, <16 x i8>* %272
%273 = bitcast i8* %267 to <16 x i8>*
store <16 x i8> %271, <16 x i8>* %273
br label %274
274: ; preds = %251, %254
%275 = icmp eq i64 %198, %175
br i1 %275, label %349, label %276
276: ; preds = %274
%277 = and i64 %175, 24
%278 = icmp eq i64 %277, 0
br i1 %278, label %299, label %279
279: ; preds = %195, %276
%280 = phi i64 [ %198, %276 ], [ 0, %195 ]
%281 = and i64 %175, 4294967288
br label %282
282: ; preds = %282, %279
%283 = phi i64 [ %280, %279 ], [ %295, %282 ]
%284 = trunc i64 %283 to i32
%285 = getelementptr inbounds i8, i8* %2, i64 %283
%286 = bitcast i8* %285 to <8 x i8>*
%287 = load <8 x i8>, <8 x i8>* %286
%288 = add i32 %12, %284
%289 = zext i32 %288 to i64
%290 = getelementptr inbounds i8, i8* %4, i64 %289
%291 = bitcast i8* %290 to <8 x i8>*
%292 = load <8 x i8>, <8 x i8>* %291
%293 = xor <8 x i8> %292, %287
%294 = bitcast i8* %290 to <8 x i8>*
store <8 x i8> %293, <8 x i8>* %294
%295 = add nuw i64 %283, 8
%296 = icmp eq i64 %295, %281
br i1 %296, label %297, label %282
297: ; preds = %282
%298 = icmp eq i64 %281, %175
br i1 %298, label %349, label %299
299: ; preds = %185, %177, %174, %276, %297
%300 = phi i64 [ 0, %174 ], [ 0, %185 ], [ 0, %177 ], [ %198, %276 ], [ %281, %297 ]
%301 = xor i64 %300, -1
%302 = and i64 %175, 1
%303 = icmp eq i64 %302, 0
br i1 %303, label %314, label %304
304: ; preds = %299
%305 = getelementptr inbounds i8, i8* %2, i64 %300
%306 = load i8, i8* %305
%307 = trunc i64 %300 to i32
%308 = add i32 %12, %307
%309 = zext i32 %308 to i64
%310 = getelementptr inbounds i8, i8* %4, i64 %309
%311 = load i8, i8* %310
%312 = xor i8 %311, %306
store i8 %312, i8* %310
%313 = or i64 %300, 1
br label %314
314: ; preds = %304, %299
%315 = phi i64 [ %300, %299 ], [ %313, %304 ]
%316 = sub nsw i64 0, %175
%317 = icmp eq i64 %301, %316
br i1 %317, label %349, label %350
318: ; preds = %169, %318
%319 = phi i64 [ %347, %318 ], [ %170, %169 ]
%320 = getelementptr inbounds i8, i8* %0, i64 %319
%321 = load i8, i8* %320
%322 = trunc i64 %319 to i32
%323 = add i32 %11, %322
%324 = zext i32 %323 to i64
%325 = getelementptr inbounds i8, i8* %4, i64 %324
store i8 %321, i8* %325
%326 = add nuw nsw i64 %319, 1
%327 = getelementptr inbounds i8, i8* %0, i64 %326
%328 = load i8, i8* %327
%329 = trunc i64 %326 to i32
%330 = add i32 %11, %329
%331 = zext i32 %330 to i64
%332 = getelementptr inbounds i8, i8* %4, i64 %331
store i8 %328, i8* %332
%333 = add nuw nsw i64 %319, 2
%334 = getelementptr inbounds i8, i8* %0, i64 %333
%335 = load i8, i8* %334
%336 = trunc i64 %333 to i32
%337 = add i32 %11, %336
%338 = zext i32 %337 to i64
%339 = getelementptr inbounds i8, i8* %4, i64 %338
store i8 %335, i8* %339
%340 = add nuw nsw i64 %319, 3
%341 = getelementptr inbounds i8, i8* %0, i64 %340
%342 = load i8, i8* %341
%343 = trunc i64 %340 to i32
%344 = add i32 %11, %343
%345 = zext i32 %344 to i64
%346 = getelementptr inbounds i8, i8* %4, i64 %345
store i8 %342, i8* %346
%347 = add nuw nsw i64 %319, 4
%348 = icmp eq i64 %347, %15
br i1 %348, label %172, label %318
349: ; preds = %314, %350, %274, %297, %172
ret void
350: ; preds = %314, %350
%351 = phi i64 [ %369, %350 ], [ %315, %314 ]
%352 = getelementptr inbounds i8, i8* %2, i64 %351
%353 = load i8, i8* %352
%354 = trunc i64 %351 to i32
%355 = add i32 %12, %354
%356 = zext i32 %355 to i64
%357 = getelementptr inbounds i8, i8* %4, i64 %356
%358 = load i8, i8* %357
%359 = xor i8 %358, %353
store i8 %359, i8* %357
%360 = add nuw nsw i64 %351, 1
%361 = getelementptr inbounds i8, i8* %2, i64 %360
%362 = load i8, i8* %361
%363 = trunc i64 %360 to i32
%364 = add i32 %12, %363
%365 = zext i32 %364 to i64
%366 = getelementptr inbounds i8, i8* %4, i64 %365
%367 = load i8, i8* %366
%368 = xor i8 %367, %362
store i8 %368, i8* %366
%369 = add nuw nsw i64 %351, 2
%370 = icmp eq i64 %369, %175
br i1 %370, label %349, label %350
}