#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 strlen(char *);
int concatenateStr(char *str1, char *str2, char *concat) {
  int len1, len2, i, j = 0;
  if (NULL == str1 || NULL == str2)
    return -1;
  len1 = strlen(str1);
  len2 = strlen(str2);
  for (i = 0; i < len1; i++)
    concat[i] = str1[i];
  for (i = len1; i <= (len1 + len2); i++) {
    concat[i] = str2[j];
    j++;
  }
  return 0;
}


x86 assembly (clang, -O0):
<concatenateStr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movl   $0x0,-0x30(%rbp)
xor    %eax,%eax
cmp    -0x10(%rbp),%rax
je     1143 <concatenateStr+0x33>
xor    %eax,%eax
cmp    -0x18(%rbp),%rax
jne    114f <concatenateStr+0x3f>
movl   $0xffffffff,-0x4(%rbp)
jmp    11e9 <concatenateStr+0xd9>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    119e <concatenateStr+0x8e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116e <concatenateStr+0x5e>
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jg     11e2 <concatenateStr+0xd2>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a4 <concatenateStr+0x94>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<concatenateStr>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    $0xffffffff,%ecx
test   %rdi,%rdi
je     12af <concatenateStr+0x19f>
mov    %rsi,%r14
test   %rsi,%rsi
je     12af <concatenateStr+0x19f>
mov    %rdx,%r15
mov    %rdi,%rbx
call   1030 <strlen@plt>
mov    %eax,%r12d
mov    %r14,%rdi
call   1030 <strlen@plt>
test   %r12d,%r12d
jle    11df <concatenateStr+0xcf>
mov    %r12d,%r9d
cmp    $0x8,%r12d
jb     1174 <concatenateStr+0x64>
lea    (%rbx,%r9,1),%rdx
cmp    %r15,%rdx
jbe    12ba <concatenateStr+0x1aa>
lea    (%r15,%r9,1),%rdx
cmp    %rbx,%rdx
jbe    12ba <concatenateStr+0x1aa>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %r9,%rsi
mov    %r9,%rdi
and    $0x3,%rdi
je     11a2 <concatenateStr+0x92>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rdx,1),%ecx
mov    %cl,(%r15,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1190 <concatenateStr+0x80>
cmp    $0x3,%rsi
jb     11df <concatenateStr+0xcf>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rdx,1),%ecx
mov    %cl,(%r15,%rdx,1)
movzbl 0x1(%rbx,%rdx,1),%ecx
mov    %cl,0x1(%r15,%rdx,1)
movzbl 0x2(%rbx,%rdx,1),%ecx
mov    %cl,0x2(%r15,%rdx,1)
movzbl 0x3(%rbx,%rdx,1),%ecx
mov    %cl,0x3(%r15,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    11b0 <concatenateStr+0xa0>
test   %eax,%eax
js     12ad <concatenateStr+0x19d>
add    %r12d,%eax
cmp    %eax,%r12d
cmovg  %r12d,%eax
movslq %r12d,%rdx
sub    %r12d,%eax
add    $0x1,%eax
cmp    $0x8,%eax
jb     1220 <concatenateStr+0x110>
lea    (%r15,%rdx,1),%rdi
lea    (%r14,%rax,1),%rcx
cmp    %rcx,%rdi
jae    12c7 <concatenateStr+0x1b7>
lea    (%rdx,%rax,1),%rcx
add    %r15,%rcx
cmp    %r14,%rcx
jbe    12c7 <concatenateStr+0x1b7>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %rax,%rdi
mov    %rax,%rcx
and    $0x3,%rcx
je     1257 <concatenateStr+0x147>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r14,%rsi,1),%ebx
mov    %bl,(%r15,%rdx,1)
add    $0x1,%rsi
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1240 <concatenateStr+0x130>
xor    %ecx,%ecx
cmp    $0x3,%rdi
jb     12af <concatenateStr+0x19f>
add    %r15,%rdx
add    $0x3,%rdx
sub    %rsi,%rax
add    %r14,%rsi
add    $0x3,%rsi
xor    %ecx,%ecx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x3(%rsi,%rdi,1),%ebx
mov    %bl,-0x3(%rdx,%rdi,1)
movzbl -0x2(%rsi,%rdi,1),%ebx
mov    %bl,-0x2(%rdx,%rdi,1)
movzbl -0x1(%rsi,%rdi,1),%ebx
mov    %bl,-0x1(%rdx,%rdi,1)
movzbl (%rsi,%rdi,1),%ebx
mov    %bl,(%rdx,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%rax
jne    1280 <concatenateStr+0x170>
jmp    12af <concatenateStr+0x19f>
xor    %ecx,%ecx
mov    %ecx,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%r12d
jae    12d3 <concatenateStr+0x1c3>
xor    %edx,%edx
jmp    13de <concatenateStr+0x2ce>
cmp    $0x20,%eax
jae    12fc <concatenateStr+0x1ec>
xor    %esi,%esi
jmp    14cb <concatenateStr+0x3bb>
mov    %r9d,%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    1328 <concatenateStr+0x218>
xor    %esi,%esi
jmp    1390 <concatenateStr+0x280>
mov    %eax,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rbp
mov    %rbp,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%r8d
and    $0x3,%r8d
cmp    $0x60,%rbp
jae    140f <concatenateStr+0x2ff>
xor    %ebx,%ebx
jmp    1481 <concatenateStr+0x371>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movups (%rbx,%rsi,1),%xmm0
movups 0x10(%rbx,%rsi,1),%xmm1
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
movups 0x20(%rbx,%rsi,1),%xmm0
movups 0x30(%rbx,%rsi,1),%xmm1
movups %xmm0,0x20(%r15,%rsi,1)
movups %xmm1,0x30(%r15,%rsi,1)
movups 0x40(%rbx,%rsi,1),%xmm0
movups 0x50(%rbx,%rsi,1),%xmm1
movups %xmm0,0x40(%r15,%rsi,1)
movups %xmm1,0x50(%r15,%rsi,1)
movups 0x60(%rbx,%rsi,1),%xmm0
movups 0x70(%rbx,%rsi,1),%xmm1
movups %xmm0,0x60(%r15,%rsi,1)
movups %xmm1,0x70(%r15,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1330 <concatenateStr+0x220>
test   %r8,%r8
je     13cb <concatenateStr+0x2bb>
lea    (%r15,%rsi,1),%rdi
add    $0x10,%rdi
add    %rbx,%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    13b0 <concatenateStr+0x2a0>
cmp    %r9,%rdx
je     11df <concatenateStr+0xcf>
test   $0x18,%r9b
je     1176 <concatenateStr+0x66>
mov    %rdx,%rsi
mov    %r9d,%edx
and    $0xfffffff8,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rsi,1),%rdi
mov    %rdi,(%r15,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    13f0 <concatenateStr+0x2e0>
cmp    %r9,%rdx
je     11df <concatenateStr+0xcf>
jmp    1176 <concatenateStr+0x66>
and    $0xfffffffffffffffc,%rcx
lea    (%rdx,%r15,1),%rbp
add    $0x70,%rbp
xor    %ebx,%ebx
nopl   (%rax)
movups (%r14,%rbx,1),%xmm0
movups 0x10(%r14,%rbx,1),%xmm1
movups %xmm0,-0x70(%rbp,%rbx,1)
movups %xmm1,-0x60(%rbp,%rbx,1)
movups 0x20(%r14,%rbx,1),%xmm0
movups 0x30(%r14,%rbx,1),%xmm1
movups %xmm0,-0x50(%rbp,%rbx,1)
movups %xmm1,-0x40(%rbp,%rbx,1)
movups 0x40(%r14,%rbx,1),%xmm0
movups 0x50(%r14,%rbx,1),%xmm1
movups %xmm0,-0x30(%rbp,%rbx,1)
movups %xmm1,-0x20(%rbp,%rbx,1)
movups 0x60(%r14,%rbx,1),%xmm0
movups 0x70(%r14,%rbx,1),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,1)
movups %xmm1,0x0(%rbp,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rcx
jne    1420 <concatenateStr+0x310>
test   %r8,%r8
je     14bc <concatenateStr+0x3ac>
lea    (%rbx,%r14,1),%rcx
add    $0x10,%rcx
add    %rdx,%rbx
lea    (%r15,%rbx,1),%rbp
add    $0x10,%rbp
shl    $0x5,%r8
xor    %ebx,%ebx
nop
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,1)
movups %xmm1,0x0(%rbp,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    14a0 <concatenateStr+0x390>
xor    %ecx,%ecx
cmp    %rax,%rsi
je     12af <concatenateStr+0x19f>
test   $0x18,%al
je     1501 <concatenateStr+0x3f1>
mov    %rsi,%rcx
mov    %eax,%esi
and    $0xfffffff8,%esi
add    %rsi,%rdx
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%rcx,1),%rbp
mov    %rbp,(%rdi,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    14e0 <concatenateStr+0x3d0>
xor    %ecx,%ecx
cmp    %rax,%rsi
jne    1222 <concatenateStr+0x112>
jmp    12af <concatenateStr+0x19f>
add    %rsi,%rdx
jmp    1222 <concatenateStr+0x112>

LLVM IR (-O0):
define i32 @concatenateStr(i8* %0, i8* %1, i8* %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8* %2, i8** %7
store i32 0, i32* %11
%12 = load i8*, i8** %5
%13 = icmp eq i8* null, %12
br i1 %13, label %17, label %14
14: ; preds = %3
%15 = load i8*, i8** %6
%16 = icmp eq i8* null, %15
br i1 %16, label %17, label %18
17: ; preds = %14, %3
store i32 -1, i32* %4
br label %64
18: ; preds = %14
%19 = load i8*, i8** %5
%20 = call i32 @strlen(i8* %19)
store i32 %20, i32* %8
%21 = load i8*, i8** %6
%22 = call i32 @strlen(i8* %21)
store i32 %22, i32* %9
store i32 0, i32* %10
br label %23
23: ; preds = %37, %18
%24 = load i32, i32* %10
%25 = load i32, i32* %8
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %40
27: ; preds = %23
%28 = load i8*, i8** %5
%29 = load i32, i32* %10
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %28, i64 %30
%32 = load i8, i8* %31
%33 = load i8*, i8** %7
%34 = load i32, i32* %10
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i8, i8* %33, i64 %35
store i8 %32, i8* %36
br label %37
37: ; preds = %27
%38 = load i32, i32* %10
%39 = add nsw i32 %38, 1
store i32 %39, i32* %10
br label %23
40: ; preds = %23
%41 = load i32, i32* %8
store i32 %41, i32* %10
br label %42
42: ; preds = %60, %40
%43 = load i32, i32* %10
%44 = load i32, i32* %8
%45 = load i32, i32* %9
%46 = add nsw i32 %44, %45
%47 = icmp sle i32 %43, %46
br i1 %47, label %48, label %63
48: ; preds = %42
%49 = load i8*, i8** %6
%50 = load i32, i32* %11
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i8, i8* %49, i64 %51
%53 = load i8, i8* %52
%54 = load i8*, i8** %7
%55 = load i32, i32* %10
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %54, i64 %56
store i8 %53, i8* %57
%58 = load i32, i32* %11
%59 = add nsw i32 %58, 1
store i32 %59, i32* %11
br label %60
60: ; preds = %48
%61 = load i32, i32* %10
%62 = add nsw i32 %61, 1
store i32 %62, i32* %10
br label %42
63: ; preds = %42
store i32 0, i32* %4
br label %64
64: ; preds = %63, %17
%65 = load i32, i32* %4
ret i32 %65
}

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