#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 *malloc(size_t);
char *realloc(char *, size_t);
char *xml_serialize_(const char *str, int inplace) {
  size_t count_amp = 0;
  size_t count_lt = 0;
  size_t count_gt = 0;
  size_t count_apos = 0;
  size_t count_quot = 0;
  size_t in_size = 0;
  {
    const char *s = str;
    for (; *s; ++s) {
      switch (*s) {
      case '&':
        ++count_amp;
        break;
      case '<':
        ++count_lt;
        break;
      case '>':
        ++count_gt;
        break;
      case '\'':
        ++count_apos;
        break;
      case '"':
        ++count_quot;
        break;
      default:
        break;
      }
      ++in_size;
    }
  }
  size_t out_size = in_size + 4 * count_amp + 3 * count_lt + 3 * count_gt +
                    5 * count_apos + 5 * count_quot;
  char *out = NULL;
  if (inplace) {
    str = realloc((char *)str, out_size + 1);
    out = (char *)str;
  } else
    out = malloc(out_size + 1);
  out[out_size] = 0;
  {
    const char *s = str + in_size - 1;
    char *o = out + out_size - 1;
    for (; s >= str; --s) {
      switch (*s) {
      case '&':
        *(o--) = ';';
        *(o--) = 'p';
        *(o--) = 'm';
        *(o--) = 'a';
        *(o--) = '&';
        break;
      case '<':
        *(o--) = ';';
        *(o--) = 't';
        *(o--) = 'l';
        *(o--) = '&';
        break;
      case '>':
        *(o--) = ';';
        *(o--) = 't';
        *(o--) = 'g';
        *(o--) = '&';
        break;
      case '\'':
        *(o--) = ';';
        *(o--) = 's';
        *(o--) = 'o';
        *(o--) = 'p';
        *(o--) = 'a';
        *(o--) = '&';
        break;
      case '"':
        *(o--) = ';';
        *(o--) = 't';
        *(o--) = 'o';
        *(o--) = 'u';
        *(o--) = 'q';
        *(o--) = '&';
        break;
      default:
        *(o--) = *s;
        break;
      }
    }
  }
  return out;
}


x86 assembly (clang, -O0):
<xml_serialize_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movq   $0x0,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmpb   $0x0,(%rax)
je     121b <xml_serialize_+0xfb>
mov    -0x48(%rbp),%rax
movsbl (%rax),%eax
add    $0xffffffde,%eax
mov    %eax,%ecx
mov    %rcx,-0x70(%rbp)
sub    $0x1c,%eax
ja     11f9 <xml_serialize_+0xd9>
mov    -0x70(%rbp),%rax
lea    0xed9(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    11fe <xml_serialize_+0xde>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11fe <xml_serialize_+0xde>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11fe <xml_serialize_+0xde>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11fe <xml_serialize_+0xde>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    11fe <xml_serialize_+0xde>
jmp    11fe <xml_serialize_+0xde>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    116a <xml_serialize_+0x4a>
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0x3,-0x20(%rbp),%rcx
add    %rcx,%rax
imul   $0x3,-0x28(%rbp),%rcx
add    %rcx,%rax
imul   $0x5,-0x30(%rbp),%rcx
add    %rcx,%rax
imul   $0x5,-0x38(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
cmpl   $0x0,-0xc(%rbp)
je     1282 <xml_serialize_+0x162>
mov    -0x8(%rbp),%rdi
mov    -0x50(%rbp),%rsi
add    $0x1,%rsi
call   1040 <realloc@plt>
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    1293 <xml_serialize_+0x173>
mov    -0x50(%rbp),%rdi
add    $0x1,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
add    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
add    -0x50(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x8(%rbp),%rax
jb     1502 <xml_serialize_+0x3e2>
mov    -0x60(%rbp),%rax
movsbl (%rax),%eax
add    $0xffffffde,%eax
mov    %eax,%ecx
mov    %rcx,-0x78(%rbp)
sub    $0x1c,%eax
ja     14d5 <xml_serialize_+0x3b5>
mov    -0x78(%rbp),%rax
lea    0xd0f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x3b,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x70,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x6d,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x61,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x26,(%rax)
jmp    14ec <xml_serialize_+0x3cc>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x3b,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x74,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x6c,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x26,(%rax)
jmp    14ec <xml_serialize_+0x3cc>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x3b,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x74,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x67,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x26,(%rax)
jmp    14ec <xml_serialize_+0x3cc>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x3b,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x73,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x6f,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x70,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x61,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x26,(%rax)
jmp    14ec <xml_serialize_+0x3cc>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x3b,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x74,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x6f,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x75,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x71,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x68(%rbp)
movb   $0x26,(%rax)
jmp    14ec <xml_serialize_+0x3cc>
mov    -0x60(%rbp),%rax
mov    (%rax),%cl
mov    -0x68(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x68(%rbp)
mov    %cl,(%rax)
jmp    14f1 <xml_serialize_+0x3d1>
mov    -0x60(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x60(%rbp)
jmp    12bf <xml_serialize_+0x19f>
mov    -0x58(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<xml_serialize_>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%r14
mov    (%rdi),%al
test   %al,%al
je     119a <xml_serialize_+0x7a>
xor    %ebx,%ebx
lea    0xec9(%rip),%rdi
xor    %edx,%edx
xor    %r10d,%r10d
xor    %ecx,%ecx
xor    %r9d,%r9d
xor    %r8d,%r8d
jmp    115e <xml_serialize_+0x3e>
add    $0x1,%rdx
nopw   0x0(%rax,%rax,1)
movzbl 0x1(%r14,%rbx,1),%eax
add    $0x1,%rbx
test   %al,%al
je     118a <xml_serialize_+0x6a>
movsbl %al,%eax
add    $0xffffffde,%eax
cmp    $0x1c,%eax
ja     1150 <xml_serialize_+0x30>
movslq (%rdi,%rax,4),%rax
add    %rdi,%rax
jmp    *%rax
add    $0x1,%r8
jmp    1150 <xml_serialize_+0x30>
add    $0x1,%r10
jmp    1150 <xml_serialize_+0x30>
add    $0x1,%r9
jmp    1150 <xml_serialize_+0x30>
add    $0x1,%rcx
jmp    1150 <xml_serialize_+0x30>
add    %r10,%rdx
lea    (%rdx,%rdx,4),%rax
add    %r9,%rcx
lea    (%rcx,%rcx,2),%rcx
jmp    11a3 <xml_serialize_+0x83>
xor    %r8d,%r8d
xor    %ebx,%ebx
xor    %eax,%eax
xor    %ecx,%ecx
lea    (%rcx,%r8,4),%rcx
add    %rbx,%rcx
lea    (%rcx,%rax,1),%r15
add    %rcx,%rax
add    $0x1,%rax
test   %esi,%esi
je     11c9 <xml_serialize_+0xa9>
mov    %r14,%rdi
mov    %rax,%rsi
call   1040 <realloc@plt>
mov    %rax,%r14
jmp    11d1 <xml_serialize_+0xb1>
mov    %rax,%rdi
call   1030 <malloc@plt>
movb   $0x0,(%rax,%r15,1)
lea    (%r14,%rbx,1),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %r14,%rcx
jae    11e9 <xml_serialize_+0xc9>
pop    %rbx
pop    %r14
pop    %r15
ret
add    %rax,%r15
add    $0xffffffffffffffff,%r15
lea    0xe7d(%rip),%rdx
jmp    1209 <xml_serialize_+0xe9>
mov    %sil,(%r15)
add    $0xffffffffffffffff,%r15
add    $0xffffffffffffffff,%rcx
cmp    %r14,%rcx
jb     11e3 <xml_serialize_+0xc3>
movsbl (%rcx),%esi
lea    -0x22(%rsi),%edi
cmp    $0x1c,%edi
ja     11f9 <xml_serialize_+0xd9>
movslq (%rdx,%rdi,4),%rdi
add    %rdx,%rdi
jmp    *%rdi
movw   $0x3b74,-0x1(%r15)
movl   $0x6f757126,-0x5(%r15)
6f
add    $0xfffffffffffffffa,%r15
jmp    1200 <xml_serialize_+0xe0>
movb   $0x3b,(%r15)
movl   $0x706d6126,-0x4(%r15)
70
add    $0xfffffffffffffffb,%r15
jmp    1200 <xml_serialize_+0xe0>
movw   $0x3b73,-0x1(%r15)
movl   $0x6f706126,-0x5(%r15)
6f
add    $0xfffffffffffffffa,%r15
jmp    1200 <xml_serialize_+0xe0>
movl   $0x3b746c26,-0x3(%r15)
3b
add    $0xfffffffffffffffc,%r15
jmp    1200 <xml_serialize_+0xe0>
movl   $0x3b746726,-0x3(%r15)
3b
add    $0xfffffffffffffffc,%r15
jmp    1200 <xml_serialize_+0xe0>

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

LLVM IR (-O2):
define i8* @xml_serialize_(i8* %0, i32 %1) {
%3 = load i8, i8* %0
%4 = icmp eq i8 %3, 0
br i1 %4, label %40, label %5
5: ; preds = %2, %25
%6 = phi i8 [ %33, %25 ], [ %3, %2 ]
%7 = phi i8* [ %32, %25 ], [ %0, %2 ]
%8 = phi i64 [ %31, %25 ], [ 0, %2 ]
%9 = phi i64 [ %30, %25 ], [ 0, %2 ]
%10 = phi i64 [ %29, %25 ], [ 0, %2 ]
%11 = phi i64 [ %28, %25 ], [ 0, %2 ]
%12 = phi i64 [ %27, %25 ], [ 0, %2 ]
%13 = phi i64 [ %26, %25 ], [ 0, %2 ]
%14 = sext i8 %6 to i32
switch i32 %14, label %25 [
i32 38, label %15
i32 60, label %17
i32 62, label %19
i32 39, label %21
i32 34, label %23
]
15: ; preds = %5
%16 = add i64 %13, 1
br label %25
17: ; preds = %5
%18 = add i64 %12, 1
br label %25
19: ; preds = %5
%20 = add i64 %11, 1
br label %25
21: ; preds = %5
%22 = add i64 %10, 1
br label %25
23: ; preds = %5
%24 = add i64 %9, 1
br label %25
25: ; preds = %5, %23, %21, %19, %17, %15
%26 = phi i64 [ %13, %5 ], [ %13, %23 ], [ %13, %21 ], [ %13, %19 ], [ %13, %17 ], [ %16, %15 ]
%27 = phi i64 [ %12, %5 ], [ %12, %23 ], [ %12, %21 ], [ %12, %19 ], [ %18, %17 ], [ %12, %15 ]
%28 = phi i64 [ %11, %5 ], [ %11, %23 ], [ %11, %21 ], [ %20, %19 ], [ %11, %17 ], [ %11, %15 ]
%29 = phi i64 [ %10, %5 ], [ %10, %23 ], [ %22, %21 ], [ %10, %19 ], [ %10, %17 ], [ %10, %15 ]
%30 = phi i64 [ %9, %5 ], [ %24, %23 ], [ %9, %21 ], [ %9, %19 ], [ %9, %17 ], [ %9, %15 ]
%31 = add i64 %8, 1
%32 = getelementptr inbounds i8, i8* %7, i64 1
%33 = load i8, i8* %32
%34 = icmp eq i8 %33, 0
br i1 %34, label %35, label %5
35: ; preds = %25
%36 = add i64 %30, %29
%37 = mul i64 %36, 5
%38 = add i64 %28, %27
%39 = mul i64 %38, 3
br label %40
40: ; preds = %35, %2
%41 = phi i64 [ 0, %2 ], [ %26, %35 ]
%42 = phi i64 [ 0, %2 ], [ %31, %35 ]
%43 = phi i64 [ 0, %2 ], [ %37, %35 ]
%44 = phi i64 [ 0, %2 ], [ %39, %35 ]
%45 = shl i64 %41, 2
%46 = add i64 %44, %45
%47 = add i64 %46, %42
%48 = add i64 %47, %43
%49 = icmp eq i32 %1, 0
%50 = add i64 %48, 1
br i1 %49, label %53, label %51
51: ; preds = %40
%52 = tail call i8* @realloc(i8* %0, i64 %50)
br label %55
53: ; preds = %40
%54 = tail call i8* @malloc(i64 %50)
br label %55
55: ; preds = %53, %51
%56 = phi i8* [ %52, %51 ], [ %0, %53 ]
%57 = phi i8* [ %52, %51 ], [ %54, %53 ]
%58 = getelementptr inbounds i8, i8* %57, i64 %48
store i8 0, i8* %58
%59 = getelementptr inbounds i8, i8* %56, i64 %42
%60 = getelementptr inbounds i8, i8* %59, i64 -1
%61 = icmp ult i8* %60, %56
br i1 %61, label %105, label %62
62: ; preds = %55
%63 = getelementptr inbounds i8, i8* %58, i64 -1
br label %64
64: ; preds = %62, %101
%65 = phi i8* [ %103, %101 ], [ %60, %62 ]
%66 = phi i8* [ %102, %101 ], [ %63, %62 ]
%67 = load i8, i8* %65
%68 = sext i8 %67 to i32
switch i32 %68, label %99 [
i32 38, label %69
i32 60, label %75
i32 62, label %80
i32 39, label %85
i32 34, label %92
]
69: ; preds = %64
%70 = getelementptr inbounds i8, i8* %66, i64 -1
store i8 59, i8* %66
%71 = getelementptr inbounds i8, i8* %66, i64 -2
store i8 112, i8* %70
%72 = getelementptr inbounds i8, i8* %66, i64 -3
store i8 109, i8* %71
%73 = getelementptr inbounds i8, i8* %66, i64 -4
store i8 97, i8* %72
%74 = getelementptr inbounds i8, i8* %66, i64 -5
store i8 38, i8* %73
br label %101
75: ; preds = %64
%76 = getelementptr inbounds i8, i8* %66, i64 -1
store i8 59, i8* %66
%77 = getelementptr inbounds i8, i8* %66, i64 -2
store i8 116, i8* %76
%78 = getelementptr inbounds i8, i8* %66, i64 -3
store i8 108, i8* %77
%79 = getelementptr inbounds i8, i8* %66, i64 -4
store i8 38, i8* %78
br label %101
80: ; preds = %64
%81 = getelementptr inbounds i8, i8* %66, i64 -1
store i8 59, i8* %66
%82 = getelementptr inbounds i8, i8* %66, i64 -2
store i8 116, i8* %81
%83 = getelementptr inbounds i8, i8* %66, i64 -3
store i8 103, i8* %82
%84 = getelementptr inbounds i8, i8* %66, i64 -4
store i8 38, i8* %83
br label %101
85: ; preds = %64
%86 = getelementptr inbounds i8, i8* %66, i64 -1
store i8 59, i8* %66
%87 = getelementptr inbounds i8, i8* %66, i64 -2
store i8 115, i8* %86
%88 = getelementptr inbounds i8, i8* %66, i64 -3
store i8 111, i8* %87
%89 = getelementptr inbounds i8, i8* %66, i64 -4
store i8 112, i8* %88
%90 = getelementptr inbounds i8, i8* %66, i64 -5
store i8 97, i8* %89
%91 = getelementptr inbounds i8, i8* %66, i64 -6
store i8 38, i8* %90
br label %101
92: ; preds = %64
%93 = getelementptr inbounds i8, i8* %66, i64 -1
store i8 59, i8* %66
%94 = getelementptr inbounds i8, i8* %66, i64 -2
store i8 116, i8* %93
%95 = getelementptr inbounds i8, i8* %66, i64 -3
store i8 111, i8* %94
%96 = getelementptr inbounds i8, i8* %66, i64 -4
store i8 117, i8* %95
%97 = getelementptr inbounds i8, i8* %66, i64 -5
store i8 113, i8* %96
%98 = getelementptr inbounds i8, i8* %66, i64 -6
store i8 38, i8* %97
br label %101
99: ; preds = %64
%100 = getelementptr inbounds i8, i8* %66, i64 -1
store i8 %67, i8* %66
br label %101
101: ; preds = %69, %75, %80, %85, %92, %99
%102 = phi i8* [ %100, %99 ], [ %98, %92 ], [ %91, %85 ], [ %84, %80 ], [ %79, %75 ], [ %74, %69 ]
%103 = getelementptr inbounds i8, i8* %65, i64 -1
%104 = icmp ult i8* %103, %56
br i1 %104, label %105, label %64
105: ; preds = %101, %55
ret i8* %57
}