#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__ SCNormalloc(int, char *, int);
int sc_strlen(char *);
char *sc_strcat(char *A, char *B) {
  char *C = 0;
  int walker = 0;
  int length_of_A = sc_strlen(A);
  int length_of_B = sc_strlen(B);
  if (!A || !B)
    return 0;
  C = (char *)SCNormalloc(length_of_A + length_of_B + 1,
                          "/scratch/repos/new/home/jordi_armengol_estape/"
                          "c-scraper/outputs/2022-01-22/02-19-57/repos/"
                          "astrotycoon/semo/refs/heads/master/common/sccl.c",
                          352);
  for (walker = 0; walker < length_of_A; walker++)
    C[walker] = A[walker];
  for (; walker < length_of_A + length_of_B; walker++)
    C[walker] = B[walker - length_of_A];
  C[walker] = '\0';
  return C;
}


x86 assembly (clang, -O0):
<sc_strcat>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <sc_strlen@plt>
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <sc_strlen@plt>
mov    %eax,-0x2c(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     116d <sc_strcat+0x4d>
cmpq   $0x0,-0x18(%rbp)
jne    117a <sc_strcat+0x5a>
movq   $0x0,-0x8(%rbp)
jmp    1222 <sc_strcat+0x102>
mov    -0x28(%rbp),%edi
add    -0x2c(%rbp),%edi
add    $0x1,%edi
lea    0xe76(%rip),%rsi
mov    $0x160,%edx
call   1040 <SCNormalloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11cf <sc_strcat+0xaf>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%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    119f <sc_strcat+0x7f>
jmp    11d4 <sc_strcat+0xb4>
mov    -0x24(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    -0x2c(%rbp),%ecx
cmp    %ecx,%eax
jge    120e <sc_strcat+0xee>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%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    11d4 <sc_strcat+0xb4>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sc_strcat>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rsi,%r12
mov    %rdi,%rbp
call   1030 <sc_strlen@plt>
mov    %eax,%r14d
mov    %r12,%rdi
call   1030 <sc_strlen@plt>
mov    %eax,%r15d
xor    %eax,%eax
test   %rbp,%rbp
je     14e6 <sc_strcat+0x3c6>
test   %r12,%r12
je     14e6 <sc_strcat+0x3c6>
mov    %r15d,%eax
add    %r14d,%r15d
lea    (%rax,%r14,1),%edi
add    $0x1,%edi
lea    0xe97(%rip),%rsi
mov    $0x160,%edx
call   1040 <SCNormalloc@plt>
test   %r14d,%r14d
jle    1211 <sc_strcat+0xf1>
mov    %r14d,%ecx
cmp    $0x8,%r14d
jb     119f <sc_strcat+0x7f>
lea    (%rcx,%rbp,1),%rdx
cmp    %rax,%rdx
jbe    1269 <sc_strcat+0x149>
lea    (%rax,%rcx,1),%rdx
cmp    %rbp,%rdx
jbe    1269 <sc_strcat+0x149>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
mov    %rcx,%rdi
and    $0x3,%rdi
je     11d2 <sc_strcat+0xb2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x0(%rbp,%rdx,1),%ebx
mov    %bl,(%rax,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    11c0 <sc_strcat+0xa0>
cmp    $0x3,%rsi
jb     120c <sc_strcat+0xec>
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%rdx,1),%ebx
mov    %bl,(%rax,%rdx,1)
movzbl 0x1(%rbp,%rdx,1),%ebx
mov    %bl,0x1(%rax,%rdx,1)
movzbl 0x2(%rbp,%rdx,1),%ebx
mov    %bl,0x2(%rax,%rdx,1)
movzbl 0x3(%rbp,%rdx,1),%ebx
mov    %bl,0x3(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    11e0 <sc_strcat+0xc0>
mov    %r14d,%edx
jmp    1213 <sc_strcat+0xf3>
xor    %edx,%edx
mov    %edx,%ecx
cmp    %r15d,%edx
jge    14e2 <sc_strcat+0x3c2>
movslq %r14d,%r8
mov    %r15d,%r15d
mov    %r15,%r9
sub    %rcx,%r9
cmp    $0x8,%r9
jb     146b <sc_strcat+0x34b>
lea    (%rax,%rcx,1),%r11
mov    %rcx,%r14
sub    %r8,%r14
add    %r12,%r14
mov    %r15,%rdx
sub    %r8,%rdx
add    %r12,%rdx
cmp    %rdx,%r11
jae    125c <sc_strcat+0x13c>
lea    (%rax,%r15,1),%rdx
cmp    %rdx,%r14
jb     146b <sc_strcat+0x34b>
cmp    $0x20,%r9
jae    12a2 <sc_strcat+0x182>
xor    %edi,%edi
jmp    1444 <sc_strcat+0x324>
cmp    $0x20,%r14d
jae    1276 <sc_strcat+0x156>
xor    %edx,%edx
jmp    13dd <sc_strcat+0x2bd>
mov    %ecx,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rsi
jae    1325 <sc_strcat+0x205>
xor    %esi,%esi
jmp    1389 <sc_strcat+0x269>
mov    %r9,%rdi
and    $0xffffffffffffffe0,%rdi
lea    -0x20(%rdi),%rdx
mov    %rdx,%r10
shr    $0x5,%r10
add    $0x1,%r10
test   %rdx,%rdx
je     1410 <sc_strcat+0x2f0>
movabs $0xffffffffffffffc,%rsi
ff ff 0f
or     $0x2,%rsi
and    %r10,%rsi
lea    (%rax,%rcx,1),%rdx
add    $0x30,%rdx
mov    %r8,%rbx
neg    %rbx
add    %rcx,%rbx
add    $0x30,%rbx
add    %r12,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x30(%rbx,%rbp,1),%xmm0
movups -0x20(%rbx,%rbp,1),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,1)
movups %xmm1,-0x20(%rdx,%rbp,1)
movups -0x10(%rbx,%rbp,1),%xmm0
movups (%rbx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
add    $0x40,%rbp
add    $0xfffffffffffffffe,%rsi
jne    12f0 <sc_strcat+0x1d0>
jmp    1412 <sc_strcat+0x2f2>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rsi,1),%xmm0
movups 0x10(%rbp,%rsi,1),%xmm1
movups %xmm0,(%rax,%rsi,1)
movups %xmm1,0x10(%rax,%rsi,1)
movups 0x20(%rbp,%rsi,1),%xmm0
movups 0x30(%rbp,%rsi,1),%xmm1
movups %xmm0,0x20(%rax,%rsi,1)
movups %xmm1,0x30(%rax,%rsi,1)
movups 0x40(%rbp,%rsi,1),%xmm0
movups 0x50(%rbp,%rsi,1),%xmm1
movups %xmm0,0x40(%rax,%rsi,1)
movups %xmm1,0x50(%rax,%rsi,1)
movups 0x60(%rbp,%rsi,1),%xmm0
movups 0x70(%rbp,%rsi,1),%xmm1
movups %xmm0,0x60(%rax,%rsi,1)
movups %xmm1,0x70(%rax,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1330 <sc_strcat+0x210>
test   %r8,%r8
je     13cb <sc_strcat+0x2ab>
lea    (%rax,%rsi,1),%rdi
add    $0x10,%rdi
add    %rbp,%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rsi,%rbx,1),%xmm0
movups (%rsi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    13b0 <sc_strcat+0x290>
cmp    %rcx,%rdx
je     120c <sc_strcat+0xec>
test   $0x18,%cl
je     11a1 <sc_strcat+0x81>
mov    %rdx,%rsi
mov    %ecx,%edx
and    $0xfffffff8,%edx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%rbp,%rsi,1),%rdi
mov    %rdi,(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    13f0 <sc_strcat+0x2d0>
cmp    %rcx,%rdx
jne    11a1 <sc_strcat+0x81>
jmp    120c <sc_strcat+0xec>
xor    %ebp,%ebp
test   $0x1,%r10b
je     1435 <sc_strcat+0x315>
add    %rcx,%rbp
mov    %rbp,%rdx
sub    %r8,%rdx
movups (%r12,%rdx,1),%xmm0
movups 0x10(%r12,%rdx,1),%xmm1
movups %xmm0,(%rax,%rbp,1)
movups %xmm1,0x10(%rax,%rbp,1)
cmp    %rdi,%r9
je     14df <sc_strcat+0x3bf>
test   $0x18,%r9b
je     1468 <sc_strcat+0x348>
mov    %r9,%rdx
and    $0xfffffffffffffff8,%rdx
add    %rdx,%rcx
xchg   %ax,%ax
mov    (%r14,%rdi,1),%rsi
mov    %rsi,(%r11,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%rdx
jne    1450 <sc_strcat+0x330>
cmp    %rdx,%r9
jne    146b <sc_strcat+0x34b>
jmp    14df <sc_strcat+0x3bf>
add    %rdi,%rcx
mov    %r15d,%edx
sub    %ecx,%edx
mov    %rcx,%rsi
not    %rsi
add    %r15,%rsi
and    $0x3,%rdx
je     14a1 <sc_strcat+0x381>
mov    %r12,%rdi
sub    %r8,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdi,%rcx,1),%ebx
mov    %bl,(%rax,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1490 <sc_strcat+0x370>
cmp    $0x3,%rsi
jb     14df <sc_strcat+0x3bf>
sub    %r8,%r12
add    $0x3,%r12
xchg   %ax,%ax
movzbl -0x3(%r12,%rcx,1),%edx
mov    %dl,(%rax,%rcx,1)
movzbl -0x2(%r12,%rcx,1),%edx
mov    %dl,0x1(%rax,%rcx,1)
movzbl -0x1(%r12,%rcx,1),%edx
mov    %dl,0x2(%rax,%rcx,1)
movzbl (%r12,%rcx,1),%edx
mov    %dl,0x3(%rax,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    14b0 <sc_strcat+0x390>
mov    %r15,%rcx
movb   $0x0,(%rax,%rcx,1)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [139 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/astrotycoon/semo/refs/heads/master/common/sccl.c\00"
define i8* @sc_strcat(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i8* null, i8** %6
store i32 0, i32* %7
%10 = load i8*, i8** %4
%11 = call i32 @sc_strlen(i8* %10)
store i32 %11, i32* %8
%12 = load i8*, i8** %5
%13 = call i32 @sc_strlen(i8* %12)
store i32 %13, i32* %9
%14 = load i8*, i8** %4
%15 = icmp ne i8* %14, null
br i1 %15, label %16, label %19
16: ; preds = %2
%17 = load i8*, i8** %5
%18 = icmp ne i8* %17, null
br i1 %18, label %20, label %19
19: ; preds = %16, %2
store i8* null, i8** %3
br label %72
20: ; preds = %16
%21 = load i32, i32* %8
%22 = load i32, i32* %9
%23 = add nsw i32 %21, %22
%24 = add nsw i32 %23, 1
%25 = call i64 @SCNormalloc(i32 %24, i8* getelementptr inbounds ([139 x i8], [139 x i8]* @.str, i64 0, i64 0), i32 352)
%26 = inttoptr i64 %25 to i8*
store i8* %26, i8** %6
store i32 0, i32* %7
br label %27
27: ; preds = %41, %20
%28 = load i32, i32* %7
%29 = load i32, i32* %8
%30 = icmp slt i32 %28, %29
br i1 %30, label %31, label %44
31: ; preds = %27
%32 = load i8*, i8** %4
%33 = load i32, i32* %7
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i8, i8* %32, i64 %34
%36 = load i8, i8* %35
%37 = load i8*, i8** %6
%38 = load i32, i32* %7
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %37, i64 %39
store i8 %36, i8* %40
br label %41
41: ; preds = %31
%42 = load i32, i32* %7
%43 = add nsw i32 %42, 1
store i32 %43, i32* %7
br label %27
44: ; preds = %27
br label %45
45: ; preds = %63, %44
%46 = load i32, i32* %7
%47 = load i32, i32* %8
%48 = load i32, i32* %9
%49 = add nsw i32 %47, %48
%50 = icmp slt i32 %46, %49
br i1 %50, label %51, label %66
51: ; preds = %45
%52 = load i8*, i8** %5
%53 = load i32, i32* %7
%54 = load i32, i32* %8
%55 = sub nsw i32 %53, %54
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %52, i64 %56
%58 = load i8, i8* %57
%59 = load i8*, i8** %6
%60 = load i32, i32* %7
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %59, i64 %61
store i8 %58, i8* %62
br label %63
63: ; preds = %51
%64 = load i32, i32* %7
%65 = add nsw i32 %64, 1
store i32 %65, i32* %7
br label %45
66: ; preds = %45
%67 = load i8*, i8** %6
%68 = load i32, i32* %7
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8, i8* %67, i64 %69
store i8 0, i8* %70
%71 = load i8*, i8** %6
store i8* %71, i8** %3
br label %72
72: ; preds = %66, %19
%73 = load i8*, i8** %3
ret i8* %73
}

LLVM IR (-O2):
@.str = [139 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/astrotycoon/semo/refs/heads/master/common/sccl.c\00"
define i8* @sc_strcat(i8* %0, i8* %1) {
%3 = tail call i32 @sc_strlen(i8* %0)
%4 = tail call i32 @sc_strlen(i8* %1)
%5 = icmp ne i8* %0, null
%6 = icmp ne i8* %1, null
%7 = and i1 %5, %6
br i1 %7, label %8, label %305
8: ; preds = %2
%9 = add nsw i32 %4, %3
%10 = add nsw i32 %9, 1
%11 = tail call i64 @SCNormalloc(i32 %10, i8* getelementptr inbounds ([139 x i8], [139 x i8]* @.str, i64 0, i64 0), i32 352)
%12 = inttoptr i64 %11 to i8*
%13 = icmp sgt i32 %3, 0
br i1 %13, label %14, label %139
14: ; preds = %8
%15 = zext i32 %3 to i64
%16 = icmp ult i32 %3, 8
br i1 %16, label %121, label %17
17: ; preds = %14
%18 = getelementptr i8, i8* %12, i64 %15
%19 = getelementptr i8, i8* %0, i64 %15
%20 = icmp ugt i8* %19, %12
%21 = icmp ugt i8* %18, %0
%22 = and i1 %20, %21
br i1 %22, label %121, label %23
23: ; preds = %17
%24 = icmp ult i32 %3, 32
br i1 %24, label %107, label %25
25: ; preds = %23
%26 = and i64 %15, 4294967264
%27 = add nsw i64 %26, -32
%28 = lshr exact i64 %27, 5
%29 = add nuw nsw i64 %28, 1
%30 = and i64 %29, 3
%31 = icmp ult i64 %27, 96
br i1 %31, label %83, label %32
32: ; preds = %25
%33 = and i64 %29, 1152921504606846972
br label %34
34: ; preds = %34, %32
%35 = phi i64 [ 0, %32 ], [ %80, %34 ]
%36 = phi i64 [ 0, %32 ], [ %81, %34 ]
%37 = getelementptr inbounds i8, i8* %0, i64 %35
%38 = bitcast i8* %37 to <16 x i8>*
%39 = load <16 x i8>, <16 x i8>* %38
%40 = getelementptr inbounds i8, i8* %37, i64 16
%41 = bitcast i8* %40 to <16 x i8>*
%42 = load <16 x i8>, <16 x i8>* %41
%43 = getelementptr inbounds i8, i8* %12, i64 %35
%44 = bitcast i8* %43 to <16 x i8>*
store <16 x i8> %39, <16 x i8>* %44
%45 = getelementptr inbounds i8, i8* %43, i64 16
%46 = bitcast i8* %45 to <16 x i8>*
store <16 x i8> %42, <16 x i8>* %46
%47 = or i64 %35, 32
%48 = getelementptr inbounds i8, i8* %0, i64 %47
%49 = bitcast i8* %48 to <16 x i8>*
%50 = load <16 x i8>, <16 x i8>* %49
%51 = getelementptr inbounds i8, i8* %48, i64 16
%52 = bitcast i8* %51 to <16 x i8>*
%53 = load <16 x i8>, <16 x i8>* %52
%54 = getelementptr inbounds i8, i8* %12, i64 %47
%55 = bitcast i8* %54 to <16 x i8>*
store <16 x i8> %50, <16 x i8>* %55
%56 = getelementptr inbounds i8, i8* %54, i64 16
%57 = bitcast i8* %56 to <16 x i8>*
store <16 x i8> %53, <16 x i8>* %57
%58 = or i64 %35, 64
%59 = getelementptr inbounds i8, i8* %0, i64 %58
%60 = bitcast i8* %59 to <16 x i8>*
%61 = load <16 x i8>, <16 x i8>* %60
%62 = getelementptr inbounds i8, i8* %59, i64 16
%63 = bitcast i8* %62 to <16 x i8>*
%64 = load <16 x i8>, <16 x i8>* %63
%65 = getelementptr inbounds i8, i8* %12, i64 %58
%66 = bitcast i8* %65 to <16 x i8>*
store <16 x i8> %61, <16 x i8>* %66
%67 = getelementptr inbounds i8, i8* %65, i64 16
%68 = bitcast i8* %67 to <16 x i8>*
store <16 x i8> %64, <16 x i8>* %68
%69 = or i64 %35, 96
%70 = getelementptr inbounds i8, i8* %0, i64 %69
%71 = bitcast i8* %70 to <16 x i8>*
%72 = load <16 x i8>, <16 x i8>* %71
%73 = getelementptr inbounds i8, i8* %70, i64 16
%74 = bitcast i8* %73 to <16 x i8>*
%75 = load <16 x i8>, <16 x i8>* %74
%76 = getelementptr inbounds i8, i8* %12, i64 %69
%77 = bitcast i8* %76 to <16 x i8>*
store <16 x i8> %72, <16 x i8>* %77
%78 = getelementptr inbounds i8, i8* %76, i64 16
%79 = bitcast i8* %78 to <16 x i8>*
store <16 x i8> %75, <16 x i8>* %79
%80 = add nuw i64 %35, 128
%81 = add i64 %36, 4
%82 = icmp eq i64 %81, %33
br i1 %82, label %83, label %34
83: ; preds = %34, %25
%84 = phi i64 [ 0, %25 ], [ %80, %34 ]
%85 = icmp eq i64 %30, 0
br i1 %85, label %102, label %86
86: ; preds = %83, %86
%87 = phi i64 [ %99, %86 ], [ %84, %83 ]
%88 = phi i64 [ %100, %86 ], [ 0, %83 ]
%89 = getelementptr inbounds i8, i8* %0, i64 %87
%90 = bitcast i8* %89 to <16 x i8>*
%91 = load <16 x i8>, <16 x i8>* %90
%92 = getelementptr inbounds i8, i8* %89, i64 16
%93 = bitcast i8* %92 to <16 x i8>*
%94 = load <16 x i8>, <16 x i8>* %93
%95 = getelementptr inbounds i8, i8* %12, i64 %87
%96 = bitcast i8* %95 to <16 x i8>*
store <16 x i8> %91, <16 x i8>* %96
%97 = getelementptr inbounds i8, i8* %95, i64 16
%98 = bitcast i8* %97 to <16 x i8>*
store <16 x i8> %94, <16 x i8>* %98
%99 = add nuw i64 %87, 32
%100 = add i64 %88, 1
%101 = icmp eq i64 %100, %30
br i1 %101, label %102, label %86
102: ; preds = %86, %83
%103 = icmp eq i64 %26, %15
br i1 %103, label %139, label %104
104: ; preds = %102
%105 = and i64 %15, 24
%106 = icmp eq i64 %105, 0
br i1 %106, label %121, label %107
107: ; preds = %23, %104
%108 = phi i64 [ %26, %104 ], [ 0, %23 ]
%109 = and i64 %15, 4294967288
br label %110
110: ; preds = %110, %107
%111 = phi i64 [ %108, %107 ], [ %117, %110 ]
%112 = getelementptr inbounds i8, i8* %0, i64 %111
%113 = bitcast i8* %112 to <8 x i8>*
%114 = load <8 x i8>, <8 x i8>* %113
%115 = getelementptr inbounds i8, i8* %12, i64 %111
%116 = bitcast i8* %115 to <8 x i8>*
store <8 x i8> %114, <8 x i8>* %116
%117 = add nuw i64 %111, 8
%118 = icmp eq i64 %117, %109
br i1 %118, label %119, label %110
119: ; preds = %110
%120 = icmp eq i64 %109, %15
br i1 %120, label %139, label %121
121: ; preds = %17, %14, %104, %119
%122 = phi i64 [ 0, %14 ], [ 0, %17 ], [ %26, %104 ], [ %109, %119 ]
%123 = xor i64 %122, -1
%124 = add nsw i64 %123, %15
%125 = and i64 %15, 3
%126 = icmp eq i64 %125, 0
br i1 %126, label %136, label %127
127: ; preds = %121, %127
%128 = phi i64 [ %133, %127 ], [ %122, %121 ]
%129 = phi i64 [ %134, %127 ], [ 0, %121 ]
%130 = getelementptr inbounds i8, i8* %0, i64 %128
%131 = load i8, i8* %130
%132 = getelementptr inbounds i8, i8* %12, i64 %128
store i8 %131, i8* %132
%133 = add nuw nsw i64 %128, 1
%134 = add i64 %129, 1
%135 = icmp eq i64 %134, %125
br i1 %135, label %136, label %127
136: ; preds = %127, %121
%137 = phi i64 [ %122, %121 ], [ %133, %127 ]
%138 = icmp ult i64 %124, 3
br i1 %138, label %139, label %260
139: ; preds = %136, %260, %102, %119, %8
%140 = phi i32 [ 0, %8 ], [ %3, %119 ], [ %3, %102 ], [ %3, %260 ], [ %3, %136 ]
%141 = icmp slt i32 %140, %9
%142 = zext i32 %140 to i64
br i1 %141, label %143, label %302
143: ; preds = %139
%144 = sext i32 %3 to i64
%145 = zext i32 %9 to i64
%146 = sub nsw i64 %145, %142
%147 = icmp ult i64 %146, 8
br i1 %147, label %240, label %148
148: ; preds = %143
%149 = getelementptr i8, i8* %12, i64 %142
%150 = getelementptr i8, i8* %12, i64 %145
%151 = sub nsw i64 %142, %144
%152 = getelementptr i8, i8* %1, i64 %151
%153 = sub nsw i64 %145, %144
%154 = getelementptr i8, i8* %1, i64 %153
%155 = icmp ult i8* %149, %154
%156 = icmp ult i8* %152, %150
%157 = and i1 %155, %156
br i1 %157, label %240, label %158
158: ; preds = %148
%159 = icmp ult i64 %146, 32
br i1 %159, label %222, label %160
160: ; preds = %158
%161 = and i64 %146, -32
%162 = add nsw i64 %161, -32
%163 = lshr exact i64 %162, 5
%164 = add nuw nsw i64 %163, 1
%165 = and i64 %164, 1
%166 = icmp eq i64 %162, 0
br i1 %166, label %200, label %167
167: ; preds = %160
%168 = and i64 %164, 1152921504606846974
br label %169
169: ; preds = %169, %167
%170 = phi i64 [ 0, %167 ], [ %197, %169 ]
%171 = phi i64 [ 0, %167 ], [ %198, %169 ]
%172 = add i64 %170, %142
%173 = sub nsw i64 %172, %144
%174 = getelementptr inbounds i8, i8* %1, i64 %173
%175 = bitcast i8* %174 to <16 x i8>*
%176 = load <16 x i8>, <16 x i8>* %175
%177 = getelementptr inbounds i8, i8* %174, i64 16
%178 = bitcast i8* %177 to <16 x i8>*
%179 = load <16 x i8>, <16 x i8>* %178
%180 = getelementptr inbounds i8, i8* %12, i64 %172
%181 = bitcast i8* %180 to <16 x i8>*
store <16 x i8> %176, <16 x i8>* %181
%182 = getelementptr inbounds i8, i8* %180, i64 16
%183 = bitcast i8* %182 to <16 x i8>*
store <16 x i8> %179, <16 x i8>* %183
%184 = or i64 %170, 32
%185 = add i64 %184, %142
%186 = sub nsw i64 %185, %144
%187 = getelementptr inbounds i8, i8* %1, i64 %186
%188 = bitcast i8* %187 to <16 x i8>*
%189 = load <16 x i8>, <16 x i8>* %188
%190 = getelementptr inbounds i8, i8* %187, i64 16
%191 = bitcast i8* %190 to <16 x i8>*
%192 = load <16 x i8>, <16 x i8>* %191
%193 = getelementptr inbounds i8, i8* %12, i64 %185
%194 = bitcast i8* %193 to <16 x i8>*
store <16 x i8> %189, <16 x i8>* %194
%195 = getelementptr inbounds i8, i8* %193, i64 16
%196 = bitcast i8* %195 to <16 x i8>*
store <16 x i8> %192, <16 x i8>* %196
%197 = add nuw i64 %170, 64
%198 = add i64 %171, 2
%199 = icmp eq i64 %198, %168
br i1 %199, label %200, label %169
200: ; preds = %169, %160
%201 = phi i64 [ 0, %160 ], [ %197, %169 ]
%202 = icmp eq i64 %165, 0
br i1 %202, label %216, label %203
203: ; preds = %200
%204 = add i64 %201, %142
%205 = sub nsw i64 %204, %144
%206 = getelementptr inbounds i8, i8* %1, i64 %205
%207 = bitcast i8* %206 to <16 x i8>*
%208 = load <16 x i8>, <16 x i8>* %207
%209 = getelementptr inbounds i8, i8* %206, i64 16
%210 = bitcast i8* %209 to <16 x i8>*
%211 = load <16 x i8>, <16 x i8>* %210
%212 = getelementptr inbounds i8, i8* %12, i64 %204
%213 = bitcast i8* %212 to <16 x i8>*
store <16 x i8> %208, <16 x i8>* %213
%214 = getelementptr inbounds i8, i8* %212, i64 16
%215 = bitcast i8* %214 to <16 x i8>*
store <16 x i8> %211, <16 x i8>* %215
br label %216
216: ; preds = %200, %203
%217 = icmp eq i64 %146, %161
br i1 %217, label %302, label %218
218: ; preds = %216
%219 = add nsw i64 %161, %142
%220 = and i64 %146, 24
%221 = icmp eq i64 %220, 0
br i1 %221, label %240, label %222
222: ; preds = %158, %218
%223 = phi i64 [ %161, %218 ], [ 0, %158 ]
%224 = sub nsw i64 %145, %142
%225 = and i64 %224, -8
%226 = add nsw i64 %225, %142
br label %227
227: ; preds = %227, %222
%228 = phi i64 [ %223, %222 ], [ %236, %227 ]
%229 = add i64 %228, %142
%230 = sub nsw i64 %229, %144
%231 = getelementptr inbounds i8, i8* %1, i64 %230
%232 = bitcast i8* %231 to <8 x i8>*
%233 = load <8 x i8>, <8 x i8>* %232
%234 = getelementptr inbounds i8, i8* %12, i64 %229
%235 = bitcast i8* %234 to <8 x i8>*
store <8 x i8> %233, <8 x i8>* %235
%236 = add nuw i64 %228, 8
%237 = icmp eq i64 %236, %225
br i1 %237, label %238, label %227
238: ; preds = %227
%239 = icmp eq i64 %224, %225
br i1 %239, label %302, label %240
240: ; preds = %148, %143, %218, %238
%241 = phi i64 [ %142, %143 ], [ %142, %148 ], [ %219, %218 ], [ %226, %238 ]
%242 = sub nsw i64 %145, %241
%243 = xor i64 %241, -1
%244 = add nsw i64 %243, %145
%245 = and i64 %242, 3
%246 = icmp eq i64 %245, 0
br i1 %246, label %257, label %247
247: ; preds = %240, %247
%248 = phi i64 [ %254, %247 ], [ %241, %240 ]
%249 = phi i64 [ %255, %247 ], [ 0, %240 ]
%250 = sub nsw i64 %248, %144
%251 = getelementptr inbounds i8, i8* %1, i64 %250
%252 = load i8, i8* %251
%253 = getelementptr inbounds i8, i8* %12, i64 %248
store i8 %252, i8* %253
%254 = add nuw nsw i64 %248, 1
%255 = add i64 %249, 1
%256 = icmp eq i64 %255, %245
br i1 %256, label %257, label %247
257: ; preds = %247, %240
%258 = phi i64 [ %241, %240 ], [ %254, %247 ]
%259 = icmp ult i64 %244, 3
br i1 %259, label %302, label %279
260: ; preds = %136, %260
%261 = phi i64 [ %277, %260 ], [ %137, %136 ]
%262 = getelementptr inbounds i8, i8* %0, i64 %261
%263 = load i8, i8* %262
%264 = getelementptr inbounds i8, i8* %12, i64 %261
store i8 %263, i8* %264
%265 = add nuw nsw i64 %261, 1
%266 = getelementptr inbounds i8, i8* %0, i64 %265
%267 = load i8, i8* %266
%268 = getelementptr inbounds i8, i8* %12, i64 %265
store i8 %267, i8* %268
%269 = add nuw nsw i64 %261, 2
%270 = getelementptr inbounds i8, i8* %0, i64 %269
%271 = load i8, i8* %270
%272 = getelementptr inbounds i8, i8* %12, i64 %269
store i8 %271, i8* %272
%273 = add nuw nsw i64 %261, 3
%274 = getelementptr inbounds i8, i8* %0, i64 %273
%275 = load i8, i8* %274
%276 = getelementptr inbounds i8, i8* %12, i64 %273
store i8 %275, i8* %276
%277 = add nuw nsw i64 %261, 4
%278 = icmp eq i64 %277, %15
br i1 %278, label %139, label %260
279: ; preds = %257, %279
%280 = phi i64 [ %300, %279 ], [ %258, %257 ]
%281 = sub nsw i64 %280, %144
%282 = getelementptr inbounds i8, i8* %1, i64 %281
%283 = load i8, i8* %282
%284 = getelementptr inbounds i8, i8* %12, i64 %280
store i8 %283, i8* %284
%285 = add nuw nsw i64 %280, 1
%286 = sub nsw i64 %285, %144
%287 = getelementptr inbounds i8, i8* %1, i64 %286
%288 = load i8, i8* %287
%289 = getelementptr inbounds i8, i8* %12, i64 %285
store i8 %288, i8* %289
%290 = add nuw nsw i64 %280, 2
%291 = sub nsw i64 %290, %144
%292 = getelementptr inbounds i8, i8* %1, i64 %291
%293 = load i8, i8* %292
%294 = getelementptr inbounds i8, i8* %12, i64 %290
store i8 %293, i8* %294
%295 = add nuw nsw i64 %280, 3
%296 = sub nsw i64 %295, %144
%297 = getelementptr inbounds i8, i8* %1, i64 %296
%298 = load i8, i8* %297
%299 = getelementptr inbounds i8, i8* %12, i64 %295
store i8 %298, i8* %299
%300 = add nuw nsw i64 %280, 4
%301 = icmp eq i64 %300, %145
br i1 %301, label %302, label %279
302: ; preds = %257, %279, %216, %238, %139
%303 = phi i64 [ %142, %139 ], [ %145, %238 ], [ %145, %216 ], [ %145, %279 ], [ %145, %257 ]
%304 = getelementptr inbounds i8, i8* %12, i64 %303
store i8 0, i8* %304
br label %305
305: ; preds = %2, %302
%306 = phi i8* [ %12, %302 ], [ null, %2 ]
ret i8* %306
}