#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 */
char *SC68alloc(int);
char *SC68strdup(char const *);
int strlen(char const *);
char *SC68strcatdup(const char *a, const char *b) {
  if (!a) {
    return SC68strdup(b);
  } else if (!b) {
    return SC68strdup(a);
  } else {
    int lena = strlen(a), lenb = strlen(b);
    char *d = SC68alloc(lena + lenb + 1);
    if (d) {
      int i = 0;
      while (lena--) {
        d[i++] = *a++;
      }
      while (lenb--) {
        d[i++] = *b++;
      }
      d[i] = 0;
    }
    return d;
  }
}


x86 assembly (clang, -O0):
<SC68strcatdup>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    115d <SC68strcatdup+0x2d>
mov    -0x18(%rbp),%rdi
call   1050 <SC68strdup@plt>
mov    %rax,-0x8(%rbp)
jmp    124d <SC68strcatdup+0x11d>
cmpq   $0x0,-0x18(%rbp)
jne    117a <SC68strcatdup+0x4a>
mov    -0x10(%rbp),%rdi
call   1050 <SC68strdup@plt>
mov    %rax,-0x8(%rbp)
jmp    124d <SC68strcatdup+0x11d>
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%edi
add    -0x20(%rbp),%edi
add    $0x1,%edi
call   1030 <SC68alloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     1245 <SC68strcatdup+0x115>
movl   $0x0,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
je     11f5 <SC68strcatdup+0xc5>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%dl
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    11b6 <SC68strcatdup+0x86>
jmp    11fa <SC68strcatdup+0xca>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
je     1239 <SC68strcatdup+0x109>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%dl
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    11fa <SC68strcatdup+0xca>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SC68strcatdup>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r15
test   %rdi,%rdi
je     1233 <SC68strcatdup+0x103>
mov    %rdi,%rbx
test   %r15,%r15
je     1238 <SC68strcatdup+0x108>
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %eax,%r12d
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %eax,%r14d
lea    (%r12,%r14,1),%edi
add    $0x1,%edi
call   1030 <SC68alloc@plt>
xor    %ecx,%ecx
test   %rax,%rax
je     124b <SC68strcatdup+0x11b>
test   %r12d,%r12d
je     1330 <SC68strcatdup+0x200>
lea    -0x1(%r12),%r8d
cmp    $0x1f,%r8d
jb     11b3 <SC68strcatdup+0x83>
lea    (%rbx,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jae    1252 <SC68strcatdup+0x122>
lea    (%rax,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rbx,%rcx
jbe    1252 <SC68strcatdup+0x122>
xor    %ecx,%ecx
lea    -0x1(%r12),%r8d
test   $0x3,%r12b
je     11e9 <SC68strcatdup+0xb9>
lea    (%rax,%rcx,1),%r9
mov    %r12d,%edi
and    $0x3,%edi
xor    %esi,%esi
nopl   0x0(%rax)
movzbl (%rbx,%rsi,1),%edx
mov    %dl,(%r9,%rsi,1)
add    $0x1,%rsi
cmp    %esi,%edi
jne    11d0 <SC68strcatdup+0xa0>
add    %rsi,%rcx
sub    %esi,%r12d
add    %rsi,%rbx
cmp    $0x3,%r8d
jb     1330 <SC68strcatdup+0x200>
mov    %r12d,%edi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rsi,1),%edx
mov    %dl,(%rax,%rcx,1)
movzbl 0x1(%rbx,%rsi,1),%edx
mov    %dl,0x1(%rax,%rcx,1)
movzbl 0x2(%rbx,%rsi,1),%edx
mov    %dl,0x2(%rax,%rcx,1)
movzbl 0x3(%rbx,%rsi,1),%edx
mov    %dl,0x3(%rax,%rcx,1)
add    $0x4,%rcx
add    $0x4,%rsi
cmp    %esi,%edi
jne    1200 <SC68strcatdup+0xd0>
jmp    1330 <SC68strcatdup+0x200>
mov    %r15,%rdi
jmp    123b <SC68strcatdup+0x10b>
mov    %rbx,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1050 <SC68strdup@plt>
xor    %eax,%eax
jmp    14f8 <SC68strcatdup+0x3c8>
add    $0x1,%r8
mov    %r8,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdx
jae    127d <SC68strcatdup+0x14d>
xor    %edx,%edx
jmp    12e8 <SC68strcatdup+0x1b8>
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rdx,1),%xmm0
movups 0x10(%rbx,%rdx,1),%xmm1
movups %xmm0,(%rax,%rdx,1)
movups %xmm1,0x10(%rax,%rdx,1)
movups 0x20(%rbx,%rdx,1),%xmm0
movups 0x30(%rbx,%rdx,1),%xmm1
movups %xmm0,0x20(%rax,%rdx,1)
movups %xmm1,0x30(%rax,%rdx,1)
movups 0x40(%rbx,%rdx,1),%xmm0
movups 0x50(%rbx,%rdx,1),%xmm1
movups %xmm0,0x40(%rax,%rdx,1)
movups %xmm1,0x50(%rax,%rdx,1)
movups 0x60(%rbx,%rdx,1),%xmm0
movups 0x70(%rbx,%rdx,1),%xmm1
movups %xmm0,0x60(%rax,%rdx,1)
movups %xmm1,0x70(%rax,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1290 <SC68strcatdup+0x160>
test   %r9,%r9
je     132b <SC68strcatdup+0x1fb>
lea    (%rax,%rdx,1),%rdi
add    $0x10,%rdi
add    %rbx,%rdx
add    $0x10,%rdx
shl    $0x5,%r9
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdx,%rsi,1),%xmm0
movups (%rdx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdi,%rsi,1)
movups %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r9
jne    1310 <SC68strcatdup+0x1e0>
cmp    %rcx,%r8
jne    139a <SC68strcatdup+0x26a>
test   %r14d,%r14d
je     14f2 <SC68strcatdup+0x3c2>
mov    %ecx,%ecx
lea    -0x1(%r14),%r9d
cmp    $0x1f,%r9d
jb     146d <SC68strcatdup+0x33d>
lea    (%rax,%rcx,1),%rdx
lea    (%r9,%r15,1),%rsi
add    $0x1,%rsi
cmp    %rsi,%rdx
jae    136e <SC68strcatdup+0x23e>
lea    (%rcx,%r9,1),%rdx
add    %rax,%rdx
add    $0x1,%rdx
cmp    %r15,%rdx
ja     146d <SC68strcatdup+0x33d>
add    $0x1,%r9
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rdx
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x60,%rdx
jae    13a5 <SC68strcatdup+0x275>
xor    %esi,%esi
jmp    1420 <SC68strcatdup+0x2f0>
sub    %ecx,%r12d
add    %rcx,%rbx
jmp    11b5 <SC68strcatdup+0x85>
and    $0xfffffffffffffffc,%rdi
lea    (%rcx,%rax,1),%rdx
add    $0x70,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r15,%rsi,1),%xmm0
movups 0x10(%r15,%rsi,1),%xmm1
movups %xmm0,-0x70(%rdx,%rsi,1)
movups %xmm1,-0x60(%rdx,%rsi,1)
movups 0x20(%r15,%rsi,1),%xmm0
movups 0x30(%r15,%rsi,1),%xmm1
movups %xmm0,-0x50(%rdx,%rsi,1)
movups %xmm1,-0x40(%rdx,%rsi,1)
movups 0x40(%r15,%rsi,1),%xmm0
movups 0x50(%r15,%rsi,1),%xmm1
movups %xmm0,-0x30(%rdx,%rsi,1)
movups %xmm1,-0x20(%rdx,%rsi,1)
movups 0x60(%r15,%rsi,1),%xmm0
movups 0x70(%r15,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm1,(%rdx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    13c0 <SC68strcatdup+0x290>
test   %rbx,%rbx
je     145b <SC68strcatdup+0x32b>
lea    (%rsi,%r15,1),%rdx
add    $0x10,%rdx
add    %rcx,%rsi
add    %rax,%rsi
add    $0x10,%rsi
shl    $0x5,%rbx
xor    %edi,%edi
nopl   (%rax)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbx
jne    1440 <SC68strcatdup+0x310>
add    %r8,%rcx
cmp    %r8,%r9
je     14f2 <SC68strcatdup+0x3c2>
sub    %r8d,%r14d
add    %r8,%r15
lea    -0x1(%r14),%r8d
test   $0x3,%r14b
je     14a9 <SC68strcatdup+0x379>
mov    %rax,%rdi
add    %rcx,%rdi
mov    %r14d,%ebx
and    $0x3,%ebx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%r15,%rsi,1),%edx
mov    %dl,(%rdi,%rsi,1)
add    $0x1,%rsi
cmp    %esi,%ebx
jne    1490 <SC68strcatdup+0x360>
add    %rsi,%rcx
sub    %esi,%r14d
add    %rsi,%r15
cmp    $0x3,%r8d
jb     14f2 <SC68strcatdup+0x3c2>
mov    %r14d,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r15,%rsi,1),%ebx
mov    %bl,(%rax,%rcx,1)
movzbl 0x1(%r15,%rsi,1),%ebx
mov    %bl,0x1(%rax,%rcx,1)
movzbl 0x2(%r15,%rsi,1),%ebx
mov    %bl,0x2(%rax,%rcx,1)
movzbl 0x3(%r15,%rsi,1),%ebx
mov    %bl,0x3(%rax,%rcx,1)
add    $0x4,%rcx
add    $0x4,%rsi
cmp    %esi,%edx
jne    14c0 <SC68strcatdup+0x390>
mov    %ecx,%ecx
movb   $0x0,(%rax,%rcx,1)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

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