#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ memcpy(char *, char const *, int);
scalar_t__ realloc(char *, int);
int strlen(char const *);
char *appendText(char *zIn, char const *zAppend, char quote) {
  int len;
  int i;
  int nAppend = strlen(zAppend);
  int nIn = (zIn ? strlen(zIn) : 0);
  len = nAppend + nIn + 1;
  if (quote) {
    len += 2;
    for (i = 0; i < nAppend; i++) {
      if (zAppend[i] == quote)
        len++;
    }
  }
  zIn = (char *)realloc(zIn, len);
  if (!zIn) {
    return 0;
  }
  if (quote) {
    char *zCsr = &zIn[nIn];
    *zCsr++ = quote;
    for (i = 0; i < nAppend; i++) {
      *zCsr++ = zAppend[i];
      if (zAppend[i] == quote)
        *zCsr++ = quote;
    }
    *zCsr++ = quote;
    *zCsr++ = '\0';
    assert((zCsr - zIn) == len);
  } else {
    memcpy(&zIn[nIn], zAppend, nAppend);
    zIn[len - 1] = '\0';
  }
  return zIn;
}


x86 assembly (clang, -O0):
<appendText>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %dl,%al
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %al,-0x19(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x28(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     117d <appendText+0x3d>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x3c(%rbp)
jmp    1187 <appendText+0x47>
xor    %eax,%eax
mov    %eax,-0x3c(%rbp)
jmp    1187 <appendText+0x47>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpb   $0x0,-0x19(%rbp)
je     11f8 <appendText+0xb8>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11f3 <appendText+0xb3>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x19(%rbp),%ecx
cmp    %ecx,%eax
jne    11e0 <appendText+0xa0>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11e5 <appendText+0xa5>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b3 <appendText+0x73>
jmp    11f8 <appendText+0xb8>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%esi
call   1060 <realloc@plt>
mov    %rax,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1220 <appendText+0xe0>
movq   $0x0,-0x8(%rbp)
jmp    1335 <appendText+0x1f5>
cmpb   $0x0,-0x19(%rbp)
je     1305 <appendText+0x1c5>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x19(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    12bb <appendText+0x17b>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x19(%rbp),%ecx
cmp    %ecx,%eax
jne    12a8 <appendText+0x168>
mov    -0x19(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    12ad <appendText+0x16d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1254 <appendText+0x114>
mov    -0x19(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
movslq -0x20(%rbp),%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
jmp    132d <appendText+0x1ed>
mov    -0x10(%rbp),%rdi
movslq -0x2c(%rbp),%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%edx
call   1050 <memcpy@plt>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<appendText>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edx,%r13d
mov    %rsi,%rbx
mov    %rdi,%r12
mov    %rsi,%rdi
call   1030 <strlen@plt>
mov    %eax,%r14d
test   %r12,%r12
je     1171 <appendText+0x31>
mov    %r12,%rdi
call   1030 <strlen@plt>
mov    %eax,%r15d
jmp    1174 <appendText+0x34>
xor    %r15d,%r15d
lea    (%r15,%r14,1),%ebp
test   %r13b,%r13b
je     119d <appendText+0x5d>
mov    %r15,(%rsp)
add    $0x3,%ebp
mov    %r14d,%r15d
test   %r14d,%r14d
jle    1304 <appendText+0x1c4>
cmp    $0x8,%r14d
jae    11d2 <appendText+0x92>
xor    %eax,%eax
jmp    12f0 <appendText+0x1b0>
lea    0x1(%rbp),%esi
mov    %r12,%rdi
call   1060 <realloc@plt>
test   %rax,%rax
je     1359 <appendText+0x219>
mov    %rax,%r12
movslq %r15d,%rdi
add    %rax,%rdi
mov    %rbx,%rsi
mov    %r14d,%edx
call   1050 <memcpy@plt>
movslq %ebp,%rax
movb   $0x0,(%r12,%rax,1)
jmp    13ef <appendText+0x2af>
mov    %r15d,%eax
and    $0xfffffff8,%eax
movd   %ebp,%xmm0
movzbl %r13b,%ecx
movd   %ecx,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm2
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     13b8 <appendText+0x278>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm1,%xmm1
xor    %edx,%edx
movdqa 0xde6(%rip),%xmm3
nopw   0x0(%rax,%rax,1)
movd   (%rbx,%rdx,1),%xmm5
movd   0x4(%rbx,%rdx,1),%xmm4
pcmpeqb %xmm2,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm0,%xmm5
pcmpeqb %xmm2,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rbx,%rdx,1),%xmm0
movd   0xc(%rbx,%rdx,1),%xmm1
pcmpeqb %xmm2,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm3,%xmm0
paddd  %xmm5,%xmm0
pcmpeqb %xmm2,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm3,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1220 <appendText+0xe0>
test   $0x1,%cl
je     12d1 <appendText+0x191>
movd   (%rbx,%rdx,1),%xmm3
movd   0x4(%rbx,%rdx,1),%xmm4
pcmpeqb %xmm2,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movdqa 0xd4b(%rip),%xmm5
pand   %xmm5,%xmm3
paddd  %xmm3,%xmm0
pcmpeqb %xmm2,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm5,%xmm4
paddd  %xmm4,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
cmp    %r15,%rax
je     1304 <appendText+0x1c4>
xor    %ecx,%ecx
cmp    %r13b,(%rbx,%rax,1)
sete   %cl
add    %ecx,%ebp
add    $0x1,%rax
cmp    %rax,%r15
jne    12f0 <appendText+0x1b0>
mov    %r12,%rdi
mov    %ebp,%esi
call   1060 <realloc@plt>
test   %rax,%rax
je     1359 <appendText+0x219>
mov    %rax,%r12
movslq (%rsp),%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    %r13b,(%r12,%rcx,1)
test   %r14d,%r14d
jle    13d0 <appendText+0x290>
cmp    $0x1,%r14d
jne    1361 <appendText+0x221>
xor    %ecx,%ecx
test   $0x1,%r15b
je     13d0 <appendText+0x290>
mov    (%rbx,%rcx,1),%dl
mov    %dl,(%rax)
cmp    %r13b,(%rbx,%rcx,1)
jne    13cc <appendText+0x28c>
mov    %r13b,0x1(%rax)
add    $0x2,%rax
jmp    13d0 <appendText+0x290>
xor    %r12d,%r12d
jmp    13ef <appendText+0x2af>
mov    %r15d,%esi
and    $0xfffffffe,%esi
xor    %ecx,%ecx
jmp    1381 <appendText+0x241>
nopl   0x0(%rax,%rax,1)
mov    %r13b,0x1(%rax)
add    $0x2,%rax
add    $0x2,%rcx
cmp    %rcx,%rsi
je     1336 <appendText+0x1f6>
movzbl (%rbx,%rcx,1),%edx
mov    %dl,(%rax)
cmp    %r13b,(%rbx,%rcx,1)
jne    13a0 <appendText+0x260>
mov    %r13b,0x1(%rax)
add    $0x2,%rax
jmp    13a4 <appendText+0x264>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
movzbl 0x1(%rbx,%rcx,1),%edx
mov    %dl,(%rax)
cmp    %r13b,0x1(%rbx,%rcx,1)
je     1370 <appendText+0x230>
add    $0x1,%rax
jmp    1378 <appendText+0x238>
pxor   %xmm1,%xmm1
xor    %edx,%edx
test   $0x1,%cl
jne    1296 <appendText+0x156>
jmp    12d1 <appendText+0x191>
add    $0x1,%rax
mov    %r13b,(%rax)
movb   $0x0,0x1(%rax)
sub    %r12,%rax
add    $0x2,%rax
movslq %ebp,%rcx
xor    %edi,%edi
cmp    %rcx,%rax
sete   %dil
call   1040 <assert@plt>
mov    %r12,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i8* @appendText(i8* %0, i8* %1, i8 signext %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8*
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8 %2, i8* %7
%13 = load i8*, i8** %6
%14 = call i32 @strlen(i8* %13)
store i32 %14, i32* %10
%15 = load i8*, i8** %5
%16 = icmp ne i8* %15, null
br i1 %16, label %17, label %20
17: ; preds = %3
%18 = load i8*, i8** %5
%19 = call i32 @strlen(i8* %18)
br label %21
20: ; preds = %3
br label %21
21: ; preds = %20, %17
%22 = phi i32 [ %19, %17 ], [ 0, %20 ]
store i32 %22, i32* %11
%23 = load i32, i32* %10
%24 = load i32, i32* %11
%25 = add nsw i32 %23, %24
%26 = add nsw i32 %25, 1
store i32 %26, i32* %8
%27 = load i8, i8* %7
%28 = icmp ne i8 %27, 0
br i1 %28, label %29, label %54
29: ; preds = %21
%30 = load i32, i32* %8
%31 = add nsw i32 %30, 2
store i32 %31, i32* %8
store i32 0, i32* %9
br label %32
32: ; preds = %50, %29
%33 = load i32, i32* %9
%34 = load i32, i32* %10
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %53
36: ; preds = %32
%37 = load i8*, i8** %6
%38 = load i32, i32* %9
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %37, i64 %39
%41 = load i8, i8* %40
%42 = sext i8 %41 to i32
%43 = load i8, i8* %7
%44 = sext i8 %43 to i32
%45 = icmp eq i32 %42, %44
br i1 %45, label %46, label %49
46: ; preds = %36
%47 = load i32, i32* %8
%48 = add nsw i32 %47, 1
store i32 %48, i32* %8
br label %49
49: ; preds = %46, %36
br label %50
50: ; preds = %49
%51 = load i32, i32* %9
%52 = add nsw i32 %51, 1
store i32 %52, i32* %9
br label %32
53: ; preds = %32
br label %54
54: ; preds = %53, %21
%55 = load i8*, i8** %5
%56 = load i32, i32* %8
%57 = call i64 @realloc(i8* %55, i32 %56)
%58 = inttoptr i64 %57 to i8*
store i8* %58, i8** %5
%59 = load i8*, i8** %5
%60 = icmp ne i8* %59, null
br i1 %60, label %62, label %61
61: ; preds = %54
store i8* null, i8** %4
br label %133
62: ; preds = %54
%63 = load i8, i8* %7
%64 = icmp ne i8 %63, 0
br i1 %64, label %65, label %118
65: ; preds = %62
%66 = load i8*, i8** %5
%67 = load i32, i32* %11
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i8, i8* %66, i64 %68
store i8* %69, i8** %12
%70 = load i8, i8* %7
%71 = load i8*, i8** %12
%72 = getelementptr inbounds i8, i8* %71, i32 1
store i8* %72, i8** %12
store i8 %70, i8* %71
store i32 0, i32* %9
br label %73
73: ; preds = %99, %65
%74 = load i32, i32* %9
%75 = load i32, i32* %10
%76 = icmp slt i32 %74, %75
br i1 %76, label %77, label %102
77: ; preds = %73
%78 = load i8*, i8** %6
%79 = load i32, i32* %9
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i8, i8* %78, i64 %80
%82 = load i8, i8* %81
%83 = load i8*, i8** %12
%84 = getelementptr inbounds i8, i8* %83, i32 1
store i8* %84, i8** %12
store i8 %82, i8* %83
%85 = load i8*, i8** %6
%86 = load i32, i32* %9
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i8, i8* %85, i64 %87
%89 = load i8, i8* %88
%90 = sext i8 %89 to i32
%91 = load i8, i8* %7
%92 = sext i8 %91 to i32
%93 = icmp eq i32 %90, %92
br i1 %93, label %94, label %98
94: ; preds = %77
%95 = load i8, i8* %7
%96 = load i8*, i8** %12
%97 = getelementptr inbounds i8, i8* %96, i32 1
store i8* %97, i8** %12
store i8 %95, i8* %96
br label %98
98: ; preds = %94, %77
br label %99
99: ; preds = %98
%100 = load i32, i32* %9
%101 = add nsw i32 %100, 1
store i32 %101, i32* %9
br label %73
102: ; preds = %73
%103 = load i8, i8* %7
%104 = load i8*, i8** %12
%105 = getelementptr inbounds i8, i8* %104, i32 1
store i8* %105, i8** %12
store i8 %103, i8* %104
%106 = load i8*, i8** %12
%107 = getelementptr inbounds i8, i8* %106, i32 1
store i8* %107, i8** %12
store i8 0, i8* %106
%108 = load i8*, i8** %12
%109 = load i8*, i8** %5
%110 = ptrtoint i8* %108 to i64
%111 = ptrtoint i8* %109 to i64
%112 = sub i64 %110, %111
%113 = load i32, i32* %8
%114 = sext i32 %113 to i64
%115 = icmp eq i64 %112, %114
%116 = zext i1 %115 to i32
%117 = call i32 @assert(i32 %116)
br label %131
118: ; preds = %62
%119 = load i8*, i8** %5
%120 = load i32, i32* %11
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %119, i64 %121
%123 = load i8*, i8** %6
%124 = load i32, i32* %10
%125 = call i32 @memcpy(i8* %122, i8* %123, i32 %124)
%126 = load i8*, i8** %5
%127 = load i32, i32* %8
%128 = sub nsw i32 %127, 1
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i8, i8* %126, i64 %129
store i8 0, i8* %130
br label %131
131: ; preds = %118, %102
%132 = load i8*, i8** %5
store i8* %132, i8** %4
br label %133
133: ; preds = %131, %61
%134 = load i8*, i8** %4
ret i8* %134
}

LLVM IR (-O2):
define i8* @appendText(i8* %0, i8* %1, i8 signext %2) {
%4 = tail call i32 @strlen(i8* %1)
%5 = icmp eq i8* %0, null
br i1 %5, label %8, label %6
6: ; preds = %3
%7 = tail call i32 @strlen(i8* %0)
br label %8
8: ; preds = %3, %6
%9 = phi i32 [ %7, %6 ], [ 0, %3 ]
%10 = add nsw i32 %9, %4
%11 = icmp eq i8 %2, 0
br i1 %11, label %109, label %12
12: ; preds = %8
%13 = add nsw i32 %10, 3
%14 = icmp sgt i32 %4, 0
br i1 %14, label %15, label %104
15: ; preds = %12
%16 = zext i32 %4 to i64
%17 = icmp ult i32 %4, 8
br i1 %17, label %91, label %18
18: ; preds = %15
%19 = and i64 %16, 4294967288
%20 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %13, i64 0
%21 = insertelement <4 x i8> poison, i8 %2, i64 0
%22 = shufflevector <4 x i8> %21, <4 x i8> poison, <4 x i32> zeroinitializer
%23 = insertelement <4 x i8> poison, i8 %2, i64 0
%24 = shufflevector <4 x i8> %23, <4 x i8> poison, <4 x i32> zeroinitializer
%25 = add nsw i64 %19, -8
%26 = lshr exact i64 %25, 3
%27 = add nuw nsw i64 %26, 1
%28 = and i64 %27, 1
%29 = icmp eq i64 %25, 0
br i1 %29, label %65, label %30
30: ; preds = %18
%31 = and i64 %27, 4611686018427387902
br label %32
32: ; preds = %32, %30
%33 = phi i64 [ 0, %30 ], [ %62, %32 ]
%34 = phi <4 x i32> [ %20, %30 ], [ %60, %32 ]
%35 = phi <4 x i32> [ zeroinitializer, %30 ], [ %61, %32 ]
%36 = phi i64 [ 0, %30 ], [ %63, %32 ]
%37 = getelementptr inbounds i8, i8* %1, i64 %33
%38 = bitcast i8* %37 to <4 x i8>*
%39 = load <4 x i8>, <4 x i8>* %38
%40 = getelementptr inbounds i8, i8* %37, i64 4
%41 = bitcast i8* %40 to <4 x i8>*
%42 = load <4 x i8>, <4 x i8>* %41
%43 = icmp eq <4 x i8> %39, %22
%44 = icmp eq <4 x i8> %42, %24
%45 = zext <4 x i1> %43 to <4 x i32>
%46 = zext <4 x i1> %44 to <4 x i32>
%47 = add <4 x i32> %34, %45
%48 = add <4 x i32> %35, %46
%49 = or i64 %33, 8
%50 = getelementptr inbounds i8, i8* %1, i64 %49
%51 = bitcast i8* %50 to <4 x i8>*
%52 = load <4 x i8>, <4 x i8>* %51
%53 = getelementptr inbounds i8, i8* %50, i64 4
%54 = bitcast i8* %53 to <4 x i8>*
%55 = load <4 x i8>, <4 x i8>* %54
%56 = icmp eq <4 x i8> %52, %22
%57 = icmp eq <4 x i8> %55, %24
%58 = zext <4 x i1> %56 to <4 x i32>
%59 = zext <4 x i1> %57 to <4 x i32>
%60 = add <4 x i32> %47, %58
%61 = add <4 x i32> %48, %59
%62 = add nuw i64 %33, 16
%63 = add i64 %36, 2
%64 = icmp eq i64 %63, %31
br i1 %64, label %65, label %32
65: ; preds = %32, %18
%66 = phi <4 x i32> [ undef, %18 ], [ %60, %32 ]
%67 = phi <4 x i32> [ undef, %18 ], [ %61, %32 ]
%68 = phi i64 [ 0, %18 ], [ %62, %32 ]
%69 = phi <4 x i32> [ %20, %18 ], [ %60, %32 ]
%70 = phi <4 x i32> [ zeroinitializer, %18 ], [ %61, %32 ]
%71 = icmp eq i64 %28, 0
br i1 %71, label %85, label %72
72: ; preds = %65
%73 = getelementptr inbounds i8, i8* %1, i64 %68
%74 = bitcast i8* %73 to <4 x i8>*
%75 = load <4 x i8>, <4 x i8>* %74
%76 = getelementptr inbounds i8, i8* %73, i64 4
%77 = bitcast i8* %76 to <4 x i8>*
%78 = load <4 x i8>, <4 x i8>* %77
%79 = icmp eq <4 x i8> %75, %22
%80 = icmp eq <4 x i8> %78, %24
%81 = zext <4 x i1> %79 to <4 x i32>
%82 = zext <4 x i1> %80 to <4 x i32>
%83 = add <4 x i32> %69, %81
%84 = add <4 x i32> %70, %82
br label %85
85: ; preds = %65, %72
%86 = phi <4 x i32> [ %66, %65 ], [ %83, %72 ]
%87 = phi <4 x i32> [ %67, %65 ], [ %84, %72 ]
%88 = add <4 x i32> %87, %86
%89 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %88)
%90 = icmp eq i64 %19, %16
br i1 %90, label %104, label %91
91: ; preds = %15, %85
%92 = phi i64 [ 0, %15 ], [ %19, %85 ]
%93 = phi i32 [ %13, %15 ], [ %89, %85 ]
br label %94
94: ; preds = %91, %94
%95 = phi i64 [ %102, %94 ], [ %92, %91 ]
%96 = phi i32 [ %101, %94 ], [ %93, %91 ]
%97 = getelementptr inbounds i8, i8* %1, i64 %95
%98 = load i8, i8* %97
%99 = icmp eq i8 %98, %2
%100 = zext i1 %99 to i32
%101 = add nsw i32 %96, %100
%102 = add nuw nsw i64 %95, 1
%103 = icmp eq i64 %102, %16
br i1 %103, label %104, label %94
104: ; preds = %94, %85, %12
%105 = phi i32 [ %13, %12 ], [ %89, %85 ], [ %101, %94 ]
%106 = tail call i64 @realloc(i8* %0, i32 %105)
%107 = inttoptr i64 %106 to i8*
%108 = icmp eq i64 %106, 0
br i1 %108, label %179, label %114
109: ; preds = %8
%110 = add nsw i32 %10, 1
%111 = tail call i64 @realloc(i8* %0, i32 %110)
%112 = inttoptr i64 %111 to i8*
%113 = icmp eq i64 %111, 0
br i1 %113, label %179, label %173
114: ; preds = %104
%115 = sext i32 %9 to i64
%116 = getelementptr inbounds i8, i8* %107, i64 %115
%117 = getelementptr inbounds i8, i8* %116, i64 1
store i8 %2, i8* %116
br i1 %14, label %118, label %163
118: ; preds = %114
%119 = zext i32 %4 to i64
%120 = and i64 %119, 1
%121 = icmp eq i32 %4, 1
br i1 %121, label %150, label %122
122: ; preds = %118
%123 = and i64 %119, 4294967294
br label %124
124: ; preds = %145, %122
%125 = phi i64 [ 0, %122 ], [ %147, %145 ]
%126 = phi i8* [ %117, %122 ], [ %146, %145 ]
%127 = phi i64 [ 0, %122 ], [ %148, %145 ]
%128 = getelementptr inbounds i8, i8* %1, i64 %125
%129 = load i8, i8* %128
%130 = getelementptr inbounds i8, i8* %126, i64 1
store i8 %129, i8* %126
%131 = load i8, i8* %128
%132 = icmp eq i8 %131, %2
br i1 %132, label %133, label %135
133: ; preds = %124
%134 = getelementptr inbounds i8, i8* %126, i64 2
store i8 %2, i8* %130
br label %135
135: ; preds = %124, %133
%136 = phi i8* [ %134, %133 ], [ %130, %124 ]
%137 = or i64 %125, 1
%138 = getelementptr inbounds i8, i8* %1, i64 %137
%139 = load i8, i8* %138
%140 = getelementptr inbounds i8, i8* %136, i64 1
store i8 %139, i8* %136
%141 = load i8, i8* %138
%142 = icmp eq i8 %141, %2
br i1 %142, label %143, label %145
143: ; preds = %135
%144 = getelementptr inbounds i8, i8* %136, i64 2
store i8 %2, i8* %140
br label %145
145: ; preds = %143, %135
%146 = phi i8* [ %144, %143 ], [ %140, %135 ]
%147 = add nuw nsw i64 %125, 2
%148 = add i64 %127, 2
%149 = icmp eq i64 %148, %123
br i1 %149, label %150, label %124
150: ; preds = %145, %118
%151 = phi i8* [ undef, %118 ], [ %146, %145 ]
%152 = phi i64 [ 0, %118 ], [ %147, %145 ]
%153 = phi i8* [ %117, %118 ], [ %146, %145 ]
%154 = icmp eq i64 %120, 0
br i1 %154, label %163, label %155
155: ; preds = %150
%156 = getelementptr inbounds i8, i8* %1, i64 %152
%157 = load i8, i8* %156
%158 = getelementptr inbounds i8, i8* %153, i64 1
store i8 %157, i8* %153
%159 = load i8, i8* %156
%160 = icmp eq i8 %159, %2
br i1 %160, label %161, label %163
161: ; preds = %155
%162 = getelementptr inbounds i8, i8* %153, i64 2
store i8 %2, i8* %158
br label %163
163: ; preds = %150, %161, %155, %114
%164 = phi i8* [ %117, %114 ], [ %151, %150 ], [ %162, %161 ], [ %158, %155 ]
%165 = getelementptr inbounds i8, i8* %164, i64 1
store i8 %2, i8* %164
%166 = getelementptr inbounds i8, i8* %164, i64 2
store i8 0, i8* %165
%167 = ptrtoint i8* %166 to i64
%168 = sub i64 %167, %106
%169 = sext i32 %105 to i64
%170 = icmp eq i64 %168, %169
%171 = zext i1 %170 to i32
%172 = tail call i32 @assert(i32 %171)
br label %179
173: ; preds = %109
%174 = sext i32 %9 to i64
%175 = getelementptr inbounds i8, i8* %112, i64 %174
%176 = tail call i32 @memcpy(i8* %175, i8* %1, i32 %4)
%177 = sext i32 %10 to i64
%178 = getelementptr inbounds i8, i8* %112, i64 %177
store i8 0, i8* %178
br label %179
179: ; preds = %109, %163, %173, %104
%180 = phi i8* [ null, %104 ], [ %112, %173 ], [ %107, %163 ], [ null, %109 ]
ret i8* %180
}