#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 const *);
void new_str_prepend(char *base, const char *app) {
  int plen = strlen(app);
  int blen = strlen(base);
  char *tmp = base;
  tmp[blen + plen] = 0;
  while (blen--) {
    tmp[blen + plen] = tmp[blen];
  }
  while (plen--) {
    tmp[plen] = app[plen];
  }
}


x86 assembly (clang, -O0):
<new_str_prepend>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
cmp    $0x0,%eax
je     1185 <new_str_prepend+0x75>
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1151 <new_str_prepend+0x41>
jmp    118a <new_str_prepend+0x7a>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     11b9 <new_str_prepend+0xa9>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    118a <new_str_prepend+0x7a>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<new_str_prepend>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %rsi,%rdi
call   1030 <strlen@plt>
mov    %eax,%r15d
mov    %rbx,%rdi
call   1030 <strlen@plt>
lea    (%rax,%r15,1),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rbx,%rcx,1)
movslq %r15d,%r13
test   %eax,%eax
je     123e <new_str_prepend+0x12e>
movslq %eax,%r12
add    $0xffffffff,%eax
cmp    $0x3,%eax
jae    118e <new_str_prepend+0x7e>
mov    %r12,%rsi
lea    -0x1(%rsi),%ebp
mov    %esi,%edx
and    $0x3,%edx
je     11fb <new_str_prepend+0xeb>
lea    (%rbx,%r13,1),%rdi
add    $0xffffffffffffffff,%rdi
xchg   %ax,%ax
lea    -0x1(%rsi),%rax
movzbl -0x1(%rbx,%rsi,1),%ecx
mov    %cl,(%rdi,%rsi,1)
mov    %rax,%rsi
add    $0xffffffff,%edx
jne    1170 <new_str_prepend+0x60>
cmp    $0x3,%ebp
jae    1203 <new_str_prepend+0xf3>
jmp    123e <new_str_prepend+0x12e>
lea    (%r12,%r13,1),%r10
lea    (%rbx,%r10,1),%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rcx,%rdx
ja     1155 <new_str_prepend+0x45>
lea    (%r12,%rbx,1),%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rcx,%rdx
ja     1155 <new_str_prepend+0x45>
mov    %rax,%rcx
not    %rcx
lea    (%r10,%rcx,1),%rdx
add    %rbx,%rdx
lea    (%rbx,%r12,1),%rsi
cmp    %rsi,%rdx
jae    11e1 <new_str_prepend+0xd1>
lea    (%rbx,%r10,1),%rdx
add    %r12,%rcx
add    %rbx,%rcx
cmp    %rdx,%rcx
jb     1155 <new_str_prepend+0x45>
movabs $0x1fffffff0,%r8
cmp    $0xf,%eax
jae    1346 <new_str_prepend+0x236>
xor    %edi,%edi
jmp    1513 <new_str_prepend+0x403>
mov    %rsi,%rax
cmp    $0x3,%ebp
jb     123e <new_str_prepend+0x12e>
lea    (%rbx,%r13,1),%rcx
add    $0xffffffffffffffff,%rcx
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%rbx,%rax,1),%edx
mov    %dl,(%rcx,%rax,1)
movzbl -0x2(%rbx,%rax,1),%edx
mov    %dl,-0x1(%rcx,%rax,1)
movzbl -0x3(%rbx,%rax,1),%edx
mov    %dl,-0x2(%rcx,%rax,1)
movzbl -0x4(%rbx,%rax,1),%edx
mov    %dl,-0x3(%rcx,%rax,1)
lea    -0x4(%rax),%rdx
mov    %rdx,%rax
test   %edx,%edx
jne    1210 <new_str_prepend+0x100>
test   %r15d,%r15d
je     12f3 <new_str_prepend+0x1e3>
add    $0xffffffff,%r15d
cmp    $0x3,%r15d
jb     127b <new_str_prepend+0x16b>
mov    %r15,%rax
not    %rax
add    %r13,%rax
lea    (%rbx,%rax,1),%rcx
lea    (%r14,%r13,1),%rdx
cmp    %rdx,%rcx
jae    1302 <new_str_prepend+0x1f2>
lea    (%rbx,%r13,1),%rcx
add    %r14,%rax
cmp    %rcx,%rax
jae    1302 <new_str_prepend+0x1f2>
mov    %r13,%rdi
lea    -0x1(%rdi),%esi
mov    %edi,%edx
and    $0x3,%edx
je     12ad <new_str_prepend+0x19d>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rdi),%rax
movzbl -0x1(%r14,%rdi,1),%ecx
mov    %cl,-0x1(%rbx,%rdi,1)
mov    %rax,%rdi
add    $0xffffffff,%edx
jne    1290 <new_str_prepend+0x180>
cmp    $0x3,%esi
jae    12c0 <new_str_prepend+0x1b0>
jmp    12f3 <new_str_prepend+0x1e3>
mov    %rdi,%rax
cmp    $0x3,%esi
jb     12f3 <new_str_prepend+0x1e3>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x1(%r14,%rax,1),%ecx
mov    %cl,-0x1(%rbx,%rax,1)
movzbl -0x2(%r14,%rax,1),%ecx
mov    %cl,-0x2(%rbx,%rax,1)
movzbl -0x3(%r14,%rax,1),%ecx
mov    %cl,-0x3(%rbx,%rax,1)
movzbl -0x4(%r14,%rax,1),%ecx
mov    %cl,-0x4(%rbx,%rax,1)
lea    -0x4(%rax),%rcx
mov    %rcx,%rax
test   %ecx,%ecx
jne    12c0 <new_str_prepend+0x1b0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x1(%r15),%rdx
movabs $0x1fffffff0,%r8
cmp    $0xf,%r15d
jae    131d <new_str_prepend+0x20d>
xor    %esi,%esi
jmp    1416 <new_str_prepend+0x306>
mov    %rdx,%rsi
and    %r8,%rsi
lea    -0x10(%rsi),%rax
mov    %rax,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x30,%rax
jae    1377 <new_str_prepend+0x267>
xor    %ecx,%ecx
jmp    13c4 <new_str_prepend+0x2b4>
lea    0x1(%rax),%r9
mov    %r9,%rdi
and    %r8,%rdi
lea    -0x10(%rdi),%rcx
mov    %rcx,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
mov    %edx,%r11d
and    $0x3,%r11d
cmp    $0x30,%rcx
jae    146d <new_str_prepend+0x35d>
xor    %esi,%esi
jmp    14c4 <new_str_prepend+0x3b4>
and    $0xfffffffffffffffc,%rdi
lea    (%rbx,%r13,1),%rax
add    $0xfffffffffffffff0,%rax
lea    (%r14,%r13,1),%rbp
add    $0xfffffffffffffff0,%rbp
xor    %ecx,%ecx
nopl   (%rax)
movups 0x0(%rbp,%rcx,1),%xmm0
movups %xmm0,(%rax,%rcx,1)
movups -0x10(%rbp,%rcx,1),%xmm0
movups %xmm0,-0x10(%rax,%rcx,1)
movups -0x20(%rbp,%rcx,1),%xmm0
movups %xmm0,-0x20(%rax,%rcx,1)
movups -0x30(%rbp,%rcx,1),%xmm0
movups %xmm0,-0x30(%rax,%rcx,1)
add    $0xffffffffffffffc0,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1390 <new_str_prepend+0x280>
neg    %rcx
test   %r9,%r9
je     1404 <new_str_prepend+0x2f4>
mov    %r13,%rdi
sub    %rcx,%rdi
lea    (%rbx,%rdi,1),%rax
add    $0xfffffffffffffff0,%rax
lea    (%r14,%rdi,1),%rcx
add    $0xfffffffffffffff0,%rcx
shl    $0x4,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rcx,%rdi,1),%xmm0
movups %xmm0,(%rax,%rdi,1)
add    $0xfffffffffffffff0,%rdi
mov    %r9,%rbp
add    %rdi,%rbp
jne    13f0 <new_str_prepend+0x2e0>
cmp    %rsi,%rdx
je     12f3 <new_str_prepend+0x1e3>
test   $0xc,%dl
je     155e <new_str_prepend+0x44e>
add    $0x1,%r15
add    $0xc,%r8
and    %r15,%r8
mov    %r13,%rdi
sub    %r8,%rdi
lea    (%rbx,%r13,1),%rax
add    $0xfffffffffffffffc,%rax
neg    %rsi
lea    (%r14,%r13,1),%rcx
add    $0xfffffffffffffffc,%rcx
and    $0xfffffffffffffffc,%rdx
neg    %rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rsi,1),%ebp
mov    %ebp,(%rax,%rsi,1)
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%rdx
jne    1450 <new_str_prepend+0x340>
cmp    %r8,%r15
jne    127e <new_str_prepend+0x16e>
jmp    12f3 <new_str_prepend+0x1e3>
and    $0xfffffffffffffffc,%rdx
lea    (%rbx,%r10,1),%rcx
add    $0xfffffffffffffff0,%rcx
lea    (%r12,%rbx,1),%rbp
add    $0xfffffffffffffff0,%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%rbp,%rsi,1),%xmm0
movups %xmm0,(%rcx,%rsi,1)
movups -0x10(%rbp,%rsi,1),%xmm0
movups %xmm0,-0x10(%rcx,%rsi,1)
movups -0x20(%rbp,%rsi,1),%xmm0
movups %xmm0,-0x20(%rcx,%rsi,1)
movups -0x30(%rbp,%rsi,1),%xmm0
movups %xmm0,-0x30(%rcx,%rsi,1)
add    $0xffffffffffffffc0,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1490 <new_str_prepend+0x380>
neg    %rsi
test   %r11,%r11
je     1504 <new_str_prepend+0x3f4>
sub    %rsi,%r10
lea    (%r10,%rbx,1),%rcx
add    $0xfffffffffffffff0,%rcx
mov    %r12,%rdx
sub    %rsi,%rdx
add    %rbx,%rdx
add    $0xfffffffffffffff0,%rdx
shl    $0x4,%r11
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%rdx,%rsi,1),%xmm0
movups %xmm0,(%rcx,%rsi,1)
add    $0xfffffffffffffff0,%rsi
mov    %r11,%rbp
add    %rsi,%rbp
jne    14f0 <new_str_prepend+0x3e0>
cmp    %rdi,%r9
je     123e <new_str_prepend+0x12e>
test   $0xc,%r9b
je     1566 <new_str_prepend+0x456>
add    $0x1,%rax
add    $0xc,%r8
and    %rax,%r8
mov    %r12,%rsi
sub    %r8,%rsi
sub    %rdi,%r12
lea    (%r12,%rbx,1),%rcx
add    $0xfffffffffffffffc,%rcx
sub    %r8,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rcx),%edx
mov    %edx,(%rcx,%r13,1)
add    $0xfffffffffffffffc,%rcx
add    $0x4,%rdi
jne    1540 <new_str_prepend+0x430>
cmp    %r8,%rax
jne    1158 <new_str_prepend+0x48>
jmp    123e <new_str_prepend+0x12e>
sub    %rsi,%r13
jmp    127b <new_str_prepend+0x16b>
sub    %rdi,%r12
jmp    1155 <new_str_prepend+0x45>

LLVM IR (-O0):
define void @new_str_prepend(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
%8 = load i8*, i8** %4
%9 = call i32 @strlen(i8* %8)
store i32 %9, i32* %5
%10 = load i8*, i8** %3
%11 = call i32 @strlen(i8* %10)
store i32 %11, i32* %6
%12 = load i8*, i8** %3
store i8* %12, i8** %7
%13 = load i8*, i8** %7
%14 = load i32, i32* %6
%15 = load i32, i32* %5
%16 = add nsw i32 %14, %15
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i8, i8* %13, i64 %17
store i8 0, i8* %18
br label %19
19: ; preds = %23, %2
%20 = load i32, i32* %6
%21 = add nsw i32 %20, -1
store i32 %21, i32* %6
%22 = icmp ne i32 %20, 0
br i1 %22, label %23, label %35
23: ; preds = %19
%24 = load i8*, i8** %7
%25 = load i32, i32* %6
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i8, i8* %24, i64 %26
%28 = load i8, i8* %27
%29 = load i8*, i8** %7
%30 = load i32, i32* %6
%31 = load i32, i32* %5
%32 = add nsw i32 %30, %31
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %29, i64 %33
store i8 %28, i8* %34
br label %19
35: ; preds = %19
br label %36
36: ; preds = %40, %35
%37 = load i32, i32* %5
%38 = add nsw i32 %37, -1
store i32 %38, i32* %5
%39 = icmp ne i32 %37, 0
br i1 %39, label %40, label %50
40: ; preds = %36
%41 = load i8*, i8** %4
%42 = load i32, i32* %5
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %41, i64 %43
%45 = load i8, i8* %44
%46 = load i8*, i8** %7
%47 = load i32, i32* %5
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i8, i8* %46, i64 %48
store i8 %45, i8* %49
br label %36
50: ; preds = %36
ret void
}

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