#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*/ memcpy(char *, char const *, int);
scalar_t__ sqlite3_realloc(long *, long);
int strlen(char const *);
char *append(char **in, char const *append, char quote) {
  long *p = (long *)*in;
  long len, maxlen, actlen;
  int i;
  char *pp;
  int nappend = append ? strlen(append) : 0;
  if (p) {
    p -= 2;
    maxlen = p[0];
    actlen = p[1];
  } else {
    maxlen = actlen = 0;
  }
  len = nappend + actlen;
  if (quote) {
    len += 2;
    for (i = 0; i < nappend; i++) {
      if (append[i] == quote) {
        len++;
      }
    }
  } else if (!nappend) {
    return *in;
  }
  if (len >= maxlen - 1) {
    long *q;
    maxlen = (len + 0x03ff) & (~0x3ff);
    q = (long *)sqlite3_realloc(p, maxlen + 1 + 2 * sizeof(long));
    if (!q) {
      return 0;
    }
    if (!p) {
      q[1] = 0;
    }
    p = q;
    p[0] = maxlen;
    *in = (char *)(p + 2);
  }
  pp = *in + actlen;
  if (quote) {
    *pp++ = quote;
    for (i = 0; i < nappend; i++) {
      *pp++ = append[i];
      if (append[i] == quote) {
        *pp++ = quote;
      }
    }
    *pp++ = quote;
    *pp = '\0';
  } else {
    if (nappend) {
      memcpy(pp, append, nappend);
      pp += nappend;
      *pp = '\0';
    }
  }
  p[1] = pp - *in;
  return *in;
}


x86 assembly (clang, -O0):
<append>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %dl,%al
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %al,-0x19(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     116c <append+0x3c>
mov    -0x18(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x64(%rbp)
jmp    1176 <append+0x46>
xor    %eax,%eax
mov    %eax,-0x64(%rbp)
jmp    1176 <append+0x46>
mov    -0x64(%rbp),%eax
mov    %eax,-0x54(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     11af <append+0x7f>
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x40(%rbp)
jmp    11bf <append+0x8f>
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x38(%rbp)
movslq -0x54(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
cmpb   $0x0,-0x19(%rbp)
je     1230 <append+0x100>
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    122b <append+0xfb>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x19(%rbp),%ecx
cmp    %ecx,%eax
jne    1218 <append+0xe8>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    121d <append+0xed>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11e8 <append+0xb8>
jmp    124f <append+0x11f>
cmpl   $0x0,-0x54(%rbp)
jne    124a <append+0x11a>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x8(%rbp)
jmp    13f5 <append+0x2c5>
jmp    124f <append+0x11f>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jl     12e2 <append+0x1b2>
mov    -0x30(%rbp),%rax
add    $0x3ff,%rax
and    $0xfffffffffffffc00,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x38(%rbp),%rsi
add    $0x1,%rsi
add    $0x10,%rsi
call   1050 <sqlite3_realloc@plt>
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
jne    12a9 <append+0x179>
movq   $0x0,-0x8(%rbp)
jmp    13f5 <append+0x2c5>
cmpq   $0x0,-0x28(%rbp)
jne    12c0 <append+0x190>
mov    -0x60(%rbp),%rax
movq   $0x0,0x8(%rax)
mov    -0x60(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rcx
add    $0x10,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
cmpb   $0x0,-0x19(%rbp)
je     139d <append+0x26d>
mov    -0x19(%rbp),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    137d <append+0x24d>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x19(%rbp),%ecx
cmp    %ecx,%eax
jne    136a <append+0x23a>
mov    -0x19(%rbp),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
jmp    136f <append+0x23f>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1316 <append+0x1e6>
mov    -0x19(%rbp),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
movb   $0x0,(%rax)
jmp    13d4 <append+0x2a4>
cmpl   $0x0,-0x54(%rbp)
je     13cf <append+0x29f>
mov    -0x50(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x54(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movb   $0x0,(%rax)
jmp    13d4 <append+0x2a4>
mov    -0x50(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
sub    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<append>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edx,%r13d
mov    %rsi,%rbx
mov    %rdi,%r14
mov    (%rdi),%rbp
test   %rsi,%rsi
je     1171 <append+0x41>
mov    %rbx,%rdi
call   1030 <strlen@plt>
mov    %eax,%r12d
test   %rbp,%rbp
je     1179 <append+0x49>
lea    -0x10(%rbp),%r9
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%r10
add    $0xffffffffffffffff,%rax
jmp    1186 <append+0x56>
xor    %r12d,%r12d
test   %rbp,%rbp
jne    115f <append+0x2f>
mov    $0xffffffffffffffff,%rax
xor    %r10d,%r10d
xor    %r9d,%r9d
movslq %r12d,%r15
lea    (%r10,%r15,1),%rbp
test   %r13b,%r13b
je     11af <append+0x7f>
add    $0x2,%rbp
test   %r12d,%r12d
jle    1336 <append+0x206>
mov    %r12d,%ecx
cmp    $0x4,%r12d
jae    11c0 <append+0x90>
xor    %edx,%edx
jmp    1320 <append+0x1f0>
test   %r12d,%r12d
jne    1336 <append+0x206>
mov    (%r14),%rax
jmp    1498 <append+0x368>
mov    %ecx,%edx
and    $0xfffffffc,%edx
movq   %rbp,%xmm1
movzbl %r13b,%esi
movd   %esi,%xmm0
punpcklbw %xmm0,%xmm0
lea    -0x4(%rdx),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1469 <append+0x339>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm2,%xmm2
xor    %edi,%edi
movdqa 0xdfd(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzwl (%rbx,%rdi,1),%ebp
movd   %ebp,%xmm4
movzwl 0x2(%rbx,%rdi,1),%ebp
movd   %ebp,%xmm5
pcmpeqb %xmm0,%xmm4
punpcklbw %xmm4,%xmm4
pshuflw $0xd4,%xmm4,%xmm4
pshufd $0xd4,%xmm4,%xmm4
pand   %xmm3,%xmm4
paddq  %xmm1,%xmm4
pcmpeqb %xmm0,%xmm5
punpcklbw %xmm5,%xmm5
pshuflw $0xd4,%xmm5,%xmm1
pshufd $0xd4,%xmm1,%xmm5
pand   %xmm3,%xmm5
paddq  %xmm2,%xmm5
movzwl 0x4(%rbx,%rdi,1),%ebp
movd   %ebp,%xmm1
movzwl 0x6(%rbx,%rdi,1),%ebp
movd   %ebp,%xmm2
pcmpeqb %xmm0,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0xd4,%xmm1,%xmm1
pshufd $0xd4,%xmm1,%xmm1
pand   %xmm3,%xmm1
paddq  %xmm4,%xmm1
pcmpeqb %xmm0,%xmm2
punpcklbw %xmm2,%xmm2
pshuflw $0xd4,%xmm2,%xmm2
pshufd $0xd4,%xmm2,%xmm2
pand   %xmm3,%xmm2
paddq  %xmm5,%xmm2
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1210 <append+0xe0>
test   $0x1,%r8b
je     12fc <append+0x1cc>
movzwl (%rbx,%rdi,1),%esi
movd   %esi,%xmm3
movzwl 0x2(%rbx,%rdi,1),%esi
movd   %esi,%xmm4
pcmpeqb %xmm0,%xmm3
punpcklbw %xmm3,%xmm3
pshuflw $0xd4,%xmm3,%xmm3
pshufd $0xd4,%xmm3,%xmm3
movdqa 0xd26(%rip),%xmm5
pand   %xmm5,%xmm3
paddq  %xmm3,%xmm1
pcmpeqb %xmm0,%xmm4
punpcklbw %xmm4,%xmm4
pshuflw $0xd4,%xmm4,%xmm0
pshufd $0xd4,%xmm0,%xmm0
pand   %xmm5,%xmm0
paddq  %xmm0,%xmm2
paddq  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddq  %xmm1,%xmm0
movq   %xmm0,%rbp
cmp    %rcx,%rdx
je     1336 <append+0x206>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %esi,%esi
cmp    %r13b,(%rbx,%rdx,1)
sete   %sil
add    %rsi,%rbp
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1320 <append+0x1f0>
cmp    %rax,%rbp
jge    1340 <append+0x210>
mov    (%r14),%rbp
jmp    139d <append+0x26d>
mov    %r15,0x8(%rsp)
mov    %r10,%r15
mov    %r14,0x10(%rsp)
add    $0x3ff,%rbp
and    $0xfffffffffffffc00,%rbp
lea    0x11(%rbp),%rsi
mov    %r9,%rdi
mov    %r9,%r14
call   1050 <sqlite3_realloc@plt>
test   %rax,%rax
je     140d <append+0x2dd>
test   %r14,%r14
mov    %r15,%r10
jne    1383 <append+0x253>
movq   $0x0,0x8(%rax)
mov    %rbp,(%rax)
mov    %rax,%rbp
add    $0x10,%rbp
mov    0x10(%rsp),%r14
mov    %rbp,(%r14)
mov    %rax,%r9
mov    0x8(%rsp),%r15
add    %r10,%rbp
test   %r13b,%r13b
je     13e8 <append+0x2b8>
mov    %r13b,0x0(%rbp)
add    $0x1,%rbp
test   %r12d,%r12d
jle    1482 <append+0x352>
mov    %r12d,%esi
cmp    $0x1,%r12d
jne    1414 <append+0x2e4>
xor    %ecx,%ecx
test   $0x1,%sil
je     1482 <append+0x352>
mov    (%rbx,%rcx,1),%al
mov    %al,0x0(%rbp)
cmp    %r13b,(%rbx,%rcx,1)
jne    147e <append+0x34e>
mov    %r13b,0x1(%rbp)
add    $0x2,%rbp
jmp    1482 <append+0x352>
test   %r12d,%r12d
je     148e <append+0x35e>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12d,%edx
mov    %r9,%rbx
call   1040 <memcpy@plt>
mov    %rbx,%r9
add    %r15,%rbp
jmp    148a <append+0x35a>
xor    %eax,%eax
jmp    1498 <append+0x368>
mov    %esi,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
jmp    1431 <append+0x301>
nopl   (%rax)
mov    %r13b,0x1(%rbp)
add    $0x2,%rbp
add    $0x2,%rcx
cmp    %rcx,%rdx
je     13c1 <append+0x291>
movzbl (%rbx,%rcx,1),%eax
mov    %al,0x0(%rbp)
cmp    %r13b,(%rbx,%rcx,1)
jne    1450 <append+0x320>
mov    %r13b,0x1(%rbp)
add    $0x2,%rbp
jmp    1454 <append+0x324>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
movzbl 0x1(%rbx,%rcx,1),%eax
mov    %al,0x0(%rbp)
cmp    %r13b,0x1(%rbx,%rcx,1)
je     1420 <append+0x2f0>
add    $0x1,%rbp
jmp    1428 <append+0x2f8>
pxor   %xmm2,%xmm2
xor    %edi,%edi
test   $0x1,%r8b
jne    12af <append+0x17f>
jmp    12fc <append+0x1cc>
add    $0x1,%rbp
mov    %r13b,0x0(%rbp)
add    $0x1,%rbp
movb   $0x0,0x0(%rbp)
mov    (%r14),%rax
sub    %rax,%rbp
mov    %rbp,0x8(%r9)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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