#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*/ printf(char *, int);
int strlen(char *);
void xml_escape_symbols(char *phrase, int maxlen) {
  int j = 0, k, m, n;
  n = strlen(phrase);
  do {
    if (phrase[j] == '&') {
      k = n + 4;
      m = n;
      n = n + 4;
      if (n > maxlen) {
        printf("xml_Parse: MaxStrLen %d exceeded.\n", maxlen);
        return;
      }
      do
        phrase[k--] = phrase[m--];
      while (m > j);
      j++;
      phrase[j++] = 'a';
      phrase[j++] = 'm';
      phrase[j++] = 'p';
      phrase[j++] = ';';
    } else if (phrase[j] == '"') {
      k = n + 5;
      m = n;
      n = n + 5;
      if (n > maxlen) {
        printf("xml_Parse: MaxStrLen %d exceeded.\n", maxlen);
        return;
      }
      do
        phrase[k--] = phrase[m--];
      while (m > j);
      phrase[j++] = '&';
      phrase[j++] = 'q';
      phrase[j++] = 'u';
      phrase[j++] = 'o';
      phrase[j++] = 't';
      phrase[j++] = ';';
    } else if (phrase[j] == '<') {
      k = n + 3;
      m = n;
      n = n + 3;
      if (n > maxlen) {
        printf("xml_Parse: MaxStrLen %d exceeded.\n", maxlen);
        return;
      }
      do
        phrase[k--] = phrase[m--];
      while (m > j);
      phrase[j++] = '&';
      phrase[j++] = 'l';
      phrase[j++] = 't';
      phrase[j++] = ';';
    } else if (phrase[j] == '>') {
      k = n + 3;
      m = n;
      n = n + 3;
      if (n > maxlen) {
        printf("xml_Parse: MaxStrLen %d exceeded.\n", maxlen);
        return;
      }
      do
        phrase[k--] = phrase[m--];
      while (m > j);
      phrase[j++] = '&';
      phrase[j++] = 'g';
      phrase[j++] = 't';
      phrase[j++] = ';';
    } else
      j++;
  } while (phrase[j] != '\0');
}


x86 assembly (clang, -O0):
<xml_escape_symbols>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x26,%eax
jne    1230 <xml_escape_symbols+0x110>
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    118f <xml_escape_symbols+0x6f>
mov    -0xc(%rbp),%esi
lea    0xe7b(%rip),%rdi
call   1040 <printf@plt>
jmp    153d <xml_escape_symbols+0x41d>
jmp    1194 <xml_escape_symbols+0x74>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x18(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%esi
add    $0xffffffff,%esi
mov    %esi,-0x14(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1194 <xml_escape_symbols+0x74>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x61,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x6d,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x70,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x3b,(%rax,%rcx,1)
jmp    1523 <xml_escape_symbols+0x403>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x22,%eax
jne    1341 <xml_escape_symbols+0x221>
mov    -0x1c(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    127d <xml_escape_symbols+0x15d>
mov    -0xc(%rbp),%esi
lea    0xd8d(%rip),%rdi
call   1040 <printf@plt>
jmp    153d <xml_escape_symbols+0x41d>
jmp    1282 <xml_escape_symbols+0x162>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x18(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%esi
add    $0xffffffff,%esi
mov    %esi,-0x14(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1282 <xml_escape_symbols+0x162>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x26,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x71,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x75,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x6f,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x74,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x3b,(%rax,%rcx,1)
jmp    151e <xml_escape_symbols+0x3fe>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3c,%eax
jne    1426 <xml_escape_symbols+0x306>
mov    -0x1c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    138e <xml_escape_symbols+0x26e>
mov    -0xc(%rbp),%esi
lea    0xc7c(%rip),%rdi
call   1040 <printf@plt>
jmp    153d <xml_escape_symbols+0x41d>
jmp    1393 <xml_escape_symbols+0x273>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x18(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%esi
add    $0xffffffff,%esi
mov    %esi,-0x14(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1393 <xml_escape_symbols+0x273>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x26,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x6c,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x74,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x3b,(%rax,%rcx,1)
jmp    1519 <xml_escape_symbols+0x3f9>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3e,%eax
jne    150b <xml_escape_symbols+0x3eb>
mov    -0x1c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    1473 <xml_escape_symbols+0x353>
mov    -0xc(%rbp),%esi
lea    0xb97(%rip),%rdi
call   1040 <printf@plt>
jmp    153d <xml_escape_symbols+0x41d>
jmp    1478 <xml_escape_symbols+0x358>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x18(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%esi
add    $0xffffffff,%esi
mov    %esi,-0x14(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1478 <xml_escape_symbols+0x358>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x26,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x67,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x74,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movb   $0x3b,(%rax,%rcx,1)
jmp    1514 <xml_escape_symbols+0x3f4>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1519 <xml_escape_symbols+0x3f9>
jmp    151e <xml_escape_symbols+0x3fe>
jmp    1523 <xml_escape_symbols+0x403>
jmp    1528 <xml_escape_symbols+0x408>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1142 <xml_escape_symbols+0x22>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<xml_escape_symbols>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %esi,%r13d
mov    %rdi,%rbx
call   1030 <strlen@plt>
mov    (%rbx),%dl
lea    0x1(%rbx),%r14
lea    -0xf(%rbx),%rcx
mov    %rcx,0x10(%rsp)
lea    -0x3(%rbx),%rcx
mov    %rcx,0x20(%rsp)
xor    %r8d,%r8d
lea    0xea5(%rip),%r10
mov    %r14,0x18(%rsp)
jmp    11a9 <xml_escape_symbols+0x89>
lea    0x1(%rcx),%edx
movb   $0x26,(%rbx,%rcx,1)
mov    $0x74,%bpl
mov    $0x3,%esi
mov    $0x67,%al
mov    $0x2,%edi
add    %r8d,%edi
movslq %edx,%rcx
mov    %al,(%rbx,%rcx,1)
add    %esi,%r8d
movslq %edi,%rax
mov    %bpl,(%rbx,%rax,1)
movslq %r8d,%rax
movb   $0x3b,(%rbx,%rax,1)
mov    %r15d,%eax
movslq %r8d,%r8
mov    0x1(%rbx,%r8,1),%dl
add    $0x1,%r8
test   %dl,%dl
je     1aa6 <xml_escape_symbols+0x986>
add    $0xde,%dl
cmp    $0x1c,%dl
ja     1195 <xml_escape_symbols+0x75>
movslq %r8d,%rcx
movzbl %dl,%edx
movslq (%r10,%rdx,4),%rdx
add    %r10,%rdx
jmp    *%rdx
lea    0x5(%rax),%r15d
cmp    %r13d,%r15d
jg     1ab5 <xml_escape_symbols+0x995>
movslq %r15d,%rbp
cltq
lea    -0x1(%rax),%r12
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
mov    %rax,%r9
sub    %rdx,%r9
cmp    $0x4,%r9
jae    1339 <xml_escape_symbols+0x219>
movzbl (%rbx,%rax,1),%edx
add    $0xffffffffffffffff,%rax
mov    %dl,(%rbx,%rbp,1)
add    $0xffffffffffffffff,%rbp
cmp    %rcx,%rax
jg     11f0 <xml_escape_symbols+0xd0>
movb   $0x26,(%rbx,%rcx,1)
movw   $0x7571,0x1(%rcx,%rbx,1)
add    $0x3,%ecx
mov    $0x74,%bpl
mov    $0x5,%esi
mov    $0x6f,%al
mov    $0x4,%edi
mov    %ecx,%edx
jmp    1178 <xml_escape_symbols+0x58>
nopl   0x0(%rax,%rax,1)
lea    0x4(%rax),%r15d
cmp    %r13d,%r15d
jg     1ab5 <xml_escape_symbols+0x995>
movslq %r15d,%rbp
cltq
lea    -0x1(%rax),%r12
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
mov    %rax,%r11
sub    %rdx,%r11
cmp    $0x4,%r11
jae    13ad <xml_escape_symbols+0x28d>
movzbl (%rbx,%rax,1),%edx
add    $0xffffffffffffffff,%rax
mov    %dl,(%rbx,%rbp,1)
add    $0xffffffffffffffff,%rbp
cmp    %rcx,%rax
jg     1260 <xml_escape_symbols+0x140>
lea    0x2(%rcx),%edx
movb   $0x61,0x1(%rcx,%rbx,1)
mov    $0x70,%bpl
mov    $0x4,%esi
mov    $0x6d,%al
mov    $0x3,%edi
jmp    1178 <xml_escape_symbols+0x58>
lea    0x3(%rax),%r15d
cmp    %r13d,%r15d
jg     1ab5 <xml_escape_symbols+0x995>
movslq %r15d,%rbp
cltq
lea    -0x1(%rax),%r12
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
mov    %rax,%r9
sub    %rdx,%r9
cmp    $0x4,%r9
jae    1421 <xml_escape_symbols+0x301>
movzbl (%rbx,%rax,1),%edx
add    $0xffffffffffffffff,%rax
mov    %dl,(%rbx,%rbp,1)
add    $0xffffffffffffffff,%rbp
cmp    %rcx,%rax
jg     12c0 <xml_escape_symbols+0x1a0>
lea    0x1(%rcx),%edx
movb   $0x26,(%rbx,%rcx,1)
mov    $0x74,%bpl
mov    $0x3,%esi
mov    $0x6c,%al
jmp    1173 <xml_escape_symbols+0x53>
nopw   0x0(%rax,%rax,1)
lea    0x3(%rax),%r15d
cmp    %r13d,%r15d
jg     1ab5 <xml_escape_symbols+0x995>
movslq %r15d,%rbp
cltq
lea    -0x1(%rax),%r12
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
mov    %rax,%r9
sub    %rdx,%r9
cmp    $0x4,%r9
jae    1495 <xml_escape_symbols+0x375>
movzbl (%rbx,%rax,1),%edx
add    $0xffffffffffffffff,%rax
mov    %dl,(%rbx,%rbp,1)
add    $0xffffffffffffffff,%rbp
cmp    %rcx,%rax
jg     1320 <xml_escape_symbols+0x200>
jmp    1162 <xml_escape_symbols+0x42>
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
not    %rdx
add    %rax,%rdx
lea    (%rbx,%rbp,1),%rsi
mov    %rsi,%rdi
sub    %rdx,%rdi
cmp    %rsi,%rdi
ja     11f0 <xml_escape_symbols+0xd0>
lea    (%rbx,%rax,1),%rsi
mov    %rsi,%rdi
sub    %rdx,%rdi
cmp    %rsi,%rdi
ja     11f0 <xml_escape_symbols+0xd0>
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
lea    (%rdx,%rbp,1),%rsi
sub    %rax,%rsi
add    %r14,%rsi
lea    (%r14,%rax,1),%rdi
cmp    %rdi,%rsi
jae    139c <xml_escape_symbols+0x27c>
lea    (%r14,%rbp,1),%rsi
add    %r14,%rdx
cmp    %rsi,%rdx
jb     11f0 <xml_escape_symbols+0xd0>
cmp    $0x10,%r9
jae    1509 <xml_escape_symbols+0x3e9>
xor    %edx,%edx
jmp    16b5 <xml_escape_symbols+0x595>
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
not    %rdx
add    %rax,%rdx
lea    (%rbx,%rbp,1),%rsi
mov    %rsi,%rdi
sub    %rdx,%rdi
cmp    %rsi,%rdi
ja     1260 <xml_escape_symbols+0x140>
lea    (%rbx,%rax,1),%rsi
mov    %rsi,%rdi
sub    %rdx,%rdi
cmp    %rsi,%rdi
ja     1260 <xml_escape_symbols+0x140>
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
lea    (%rdx,%rbp,1),%rsi
sub    %rax,%rsi
add    %r14,%rsi
lea    (%r14,%rax,1),%rdi
cmp    %rdi,%rsi
jae    1410 <xml_escape_symbols+0x2f0>
lea    (%r14,%rbp,1),%rsi
add    %r14,%rdx
cmp    %rsi,%rdx
jb     1260 <xml_escape_symbols+0x140>
cmp    $0x10,%r11
jae    1545 <xml_escape_symbols+0x425>
xor    %edx,%edx
jmp    17d5 <xml_escape_symbols+0x6b5>
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
not    %rdx
add    %rax,%rdx
lea    (%rbx,%rbp,1),%rsi
mov    %rsi,%rdi
sub    %rdx,%rdi
cmp    %rsi,%rdi
ja     12c0 <xml_escape_symbols+0x1a0>
lea    (%rbx,%rax,1),%rsi
mov    %rsi,%rdi
sub    %rdx,%rdi
cmp    %rsi,%rdi
ja     12c0 <xml_escape_symbols+0x1a0>
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
lea    (%rdx,%rbp,1),%rsi
sub    %rax,%rsi
add    %r14,%rsi
lea    (%r14,%rax,1),%rdi
cmp    %rdi,%rsi
jae    1484 <xml_escape_symbols+0x364>
lea    (%r14,%rbp,1),%rsi
add    %r14,%rdx
cmp    %rsi,%rdx
jb     12c0 <xml_escape_symbols+0x1a0>
cmp    $0x10,%r9
jae    1578 <xml_escape_symbols+0x458>
xor    %edx,%edx
jmp    18f5 <xml_escape_symbols+0x7d5>
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
not    %rdx
add    %rax,%rdx
lea    (%rbx,%rbp,1),%rsi
mov    %rsi,%rdi
sub    %rdx,%rdi
cmp    %rsi,%rdi
ja     1320 <xml_escape_symbols+0x200>
lea    (%rbx,%rax,1),%rsi
mov    %rsi,%rdi
sub    %rdx,%rdi
cmp    %rsi,%rdi
ja     1320 <xml_escape_symbols+0x200>
cmp    %rcx,%r12
mov    %rcx,%rdx
cmovl  %r12,%rdx
lea    (%rdx,%rbp,1),%rsi
sub    %rax,%rsi
add    %r14,%rsi
lea    (%r14,%rax,1),%rdi
cmp    %rdi,%rsi
jae    14f8 <xml_escape_symbols+0x3d8>
lea    (%r14,%rbp,1),%rsi
add    %r14,%rdx
cmp    %rsi,%rdx
jb     1320 <xml_escape_symbols+0x200>
cmp    $0x10,%r9
jae    15b4 <xml_escape_symbols+0x494>
xor    %edx,%edx
jmp    1a15 <xml_escape_symbols+0x8f5>
mov    %r13d,0xc(%rsp)
mov    %r9,%rdx
and    $0xfffffffffffffff0,%rdx
lea    -0x10(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %esi,%r13d
and    $0x3,%r13d
cmp    $0x30,%rdi
jae    15f0 <xml_escape_symbols+0x4d0>
xor    %edi,%edi
test   %r13,%r13
jne    1655 <xml_escape_symbols+0x535>
jmp    1696 <xml_escape_symbols+0x576>
mov    %r13d,0xc(%rsp)
mov    %r11,%rdx
and    $0xfffffffffffffff0,%rdx
lea    -0x10(%rdx),%rsi
mov    %rsi,%r13
shr    $0x4,%r13
add    $0x1,%r13
mov    %r13d,%r9d
and    $0x3,%r9d
cmp    $0x30,%rsi
jae    171a <xml_escape_symbols+0x5fa>
xor    %edi,%edi
jmp    176b <xml_escape_symbols+0x64b>
mov    %r13d,0xc(%rsp)
mov    %r9,%rdx
and    $0xfffffffffffffff0,%rdx
lea    -0x10(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %esi,%r13d
and    $0x3,%r13d
cmp    $0x30,%rdi
jae    183a <xml_escape_symbols+0x71a>
xor    %edi,%edi
test   %r13,%r13
jne    1895 <xml_escape_symbols+0x775>
jmp    18d6 <xml_escape_symbols+0x7b6>
mov    %r13d,0xc(%rsp)
mov    %r9,%rdx
and    $0xfffffffffffffff0,%rdx
lea    -0x10(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %esi,%r13d
and    $0x3,%r13d
cmp    $0x30,%rdi
jae    195a <xml_escape_symbols+0x83a>
xor    %edi,%edi
test   %r13,%r13
jne    19b5 <xml_escape_symbols+0x895>
jmp    19f6 <xml_escape_symbols+0x8d6>
and    $0xfffffffffffffffc,%rsi
mov    0x10(%rsp),%rdi
lea    (%rdi,%rax,1),%r10
lea    (%rdi,%rbp,1),%r14
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r10,%rdi,1),%xmm0
movups %xmm0,(%r14,%rdi,1)
movups -0x10(%r10,%rdi,1),%xmm0
movups %xmm0,-0x10(%r14,%rdi,1)
movups -0x20(%r10,%rdi,1),%xmm0
movups %xmm0,-0x20(%r14,%rdi,1)
movups -0x30(%r10,%rdi,1),%xmm0
movups %xmm0,-0x30(%r14,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1610 <xml_escape_symbols+0x4f0>
neg    %rdi
mov    0x18(%rsp),%r14
test   %r13,%r13
je     1696 <xml_escape_symbols+0x576>
mov    %rbp,%r10
sub    %rdi,%r10
mov    0x10(%rsp),%rsi
add    %rsi,%r10
mov    %rax,%r11
sub    %rdi,%r11
add    %rsi,%r11
shl    $0x4,%r13
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r11,%rdi,1),%xmm0
movups %xmm0,(%r10,%rdi,1)
add    $0xfffffffffffffff0,%rdi
mov    %r13,%rsi
add    %rdi,%rsi
jne    1680 <xml_escape_symbols+0x560>
cmp    %rdx,%r9
mov    0xc(%rsp),%r13d
lea    0x95b(%rip),%r10
je     1204 <xml_escape_symbols+0xe4>
test   $0xc,%r9b
je     1a7a <xml_escape_symbols+0x95a>
cmp    %rcx,%r12
cmovge %rcx,%r12
mov    %rax,%r10
sub    %r12,%r10
mov    %r10,%r11
and    $0xfffffffffffffffc,%r11
and    $0xfffffffffffffffc,%r9
neg    %r9
neg    %rdx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rbp,1),%r14
sub    %r11,%rbp
lea    (%rsi,%rax,1),%rdi
sub    %r11,%rax
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%rdx,1),%esi
mov    %esi,(%r14,%rdx,1)
add    $0xfffffffffffffffc,%rdx
cmp    %rdx,%r9
jne    16f0 <xml_escape_symbols+0x5d0>
cmp    %r11,%r10
mov    0x18(%rsp),%r14
lea    0x8f1(%rip),%r10
jne    11f0 <xml_escape_symbols+0xd0>
jmp    1204 <xml_escape_symbols+0xe4>
and    $0xfffffffffffffffc,%r13
mov    0x10(%rsp),%rsi
lea    (%rsi,%rax,1),%r10
lea    (%rsi,%rbp,1),%r14
xor    %edi,%edi
nopl   (%rax)
movups (%r10,%rdi,1),%xmm0
movups %xmm0,(%r14,%rdi,1)
movups -0x10(%r10,%rdi,1),%xmm0
movups %xmm0,-0x10(%r14,%rdi,1)
movups -0x20(%r10,%rdi,1),%xmm0
movups %xmm0,-0x20(%r14,%rdi,1)
movups -0x30(%r10,%rdi,1),%xmm0
movups %xmm0,-0x30(%r14,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%r13
jne    1730 <xml_escape_symbols+0x610>
neg    %rdi
test   %r9,%r9
mov    0xc(%rsp),%r13d
je     17b6 <xml_escape_symbols+0x696>
mov    %rbp,%r10
sub    %rdi,%r10
mov    0x10(%rsp),%rsi
add    %rsi,%r10
mov    %rax,%r14
sub    %rdi,%r14
add    %rsi,%r14
shl    $0x4,%r9
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r14,%rsi,1),%xmm0
movups %xmm0,(%r10,%rsi,1)
add    $0xfffffffffffffff0,%rsi
mov    %r9,%rdi
add    %rsi,%rdi
jne    17a0 <xml_escape_symbols+0x680>
cmp    %rdx,%r11
mov    0x18(%rsp),%r14
lea    0x83b(%rip),%r10
je     1274 <xml_escape_symbols+0x154>
test   $0xc,%r11b
je     1a85 <xml_escape_symbols+0x965>
cmp    %rcx,%r12
cmovge %rcx,%r12
mov    %rax,%r9
sub    %r12,%r9
mov    %r9,%r10
and    $0xfffffffffffffffc,%r10
and    $0xfffffffffffffffc,%r11
neg    %r11
neg    %rdx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rbp,1),%r14
sub    %r10,%rbp
add    %rax,%rsi
sub    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rsi,%rdx,1),%edi
mov    %edi,(%r14,%rdx,1)
add    $0xfffffffffffffffc,%rdx
cmp    %rdx,%r11
jne    1810 <xml_escape_symbols+0x6f0>
cmp    %r10,%r9
mov    0x18(%rsp),%r14
lea    0x7d1(%rip),%r10
jne    1260 <xml_escape_symbols+0x140>
jmp    1274 <xml_escape_symbols+0x154>
and    $0xfffffffffffffffc,%rsi
mov    0x10(%rsp),%rdi
lea    (%rdi,%rax,1),%r10
lea    (%rdi,%rbp,1),%r14
xor    %edi,%edi
nopl   (%rax)
movups (%r10,%rdi,1),%xmm0
movups %xmm0,(%r14,%rdi,1)
movups -0x10(%r10,%rdi,1),%xmm0
movups %xmm0,-0x10(%r14,%rdi,1)
movups -0x20(%r10,%rdi,1),%xmm0
movups %xmm0,-0x20(%r14,%rdi,1)
movups -0x30(%r10,%rdi,1),%xmm0
movups %xmm0,-0x30(%r14,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1850 <xml_escape_symbols+0x730>
neg    %rdi
mov    0x18(%rsp),%r14
test   %r13,%r13
je     18d6 <xml_escape_symbols+0x7b6>
mov    %rbp,%r10
sub    %rdi,%r10
mov    0x10(%rsp),%rsi
add    %rsi,%r10
mov    %rax,%r11
sub    %rdi,%r11
add    %rsi,%r11
shl    $0x4,%r13
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r11,%rdi,1),%xmm0
movups %xmm0,(%r10,%rdi,1)
add    $0xfffffffffffffff0,%rdi
mov    %r13,%rsi
add    %rdi,%rsi
jne    18c0 <xml_escape_symbols+0x7a0>
cmp    %rdx,%r9
mov    0xc(%rsp),%r13d
lea    0x71b(%rip),%r10
je     12d4 <xml_escape_symbols+0x1b4>
test   $0xc,%r9b
je     1a90 <xml_escape_symbols+0x970>
cmp    %rcx,%r12
cmovge %rcx,%r12
mov    %rax,%r10
sub    %r12,%r10
mov    %r10,%r11
and    $0xfffffffffffffffc,%r11
and    $0xfffffffffffffffc,%r9
neg    %r9
neg    %rdx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rbp,1),%r14
sub    %r11,%rbp
lea    (%rsi,%rax,1),%rdi
sub    %r11,%rax
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%rdx,1),%esi
mov    %esi,(%r14,%rdx,1)
add    $0xfffffffffffffffc,%rdx
cmp    %rdx,%r9
jne    1930 <xml_escape_symbols+0x810>
cmp    %r11,%r10
mov    0x18(%rsp),%r14
lea    0x6b1(%rip),%r10
jne    12c0 <xml_escape_symbols+0x1a0>
jmp    12d4 <xml_escape_symbols+0x1b4>
and    $0xfffffffffffffffc,%rsi
mov    0x10(%rsp),%rdi
lea    (%rdi,%rax,1),%r10
lea    (%rdi,%rbp,1),%r14
xor    %edi,%edi
nopl   (%rax)
movups (%r10,%rdi,1),%xmm0
movups %xmm0,(%r14,%rdi,1)
movups -0x10(%r10,%rdi,1),%xmm0
movups %xmm0,-0x10(%r14,%rdi,1)
movups -0x20(%r10,%rdi,1),%xmm0
movups %xmm0,-0x20(%r14,%rdi,1)
movups -0x30(%r10,%rdi,1),%xmm0
movups %xmm0,-0x30(%r14,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1970 <xml_escape_symbols+0x850>
neg    %rdi
mov    0x18(%rsp),%r14
test   %r13,%r13
je     19f6 <xml_escape_symbols+0x8d6>
mov    %rbp,%r10
sub    %rdi,%r10
mov    0x10(%rsp),%rsi
add    %rsi,%r10
mov    %rax,%r11
sub    %rdi,%r11
add    %rsi,%r11
shl    $0x4,%r13
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r11,%rdi,1),%xmm0
movups %xmm0,(%r10,%rdi,1)
add    $0xfffffffffffffff0,%rdi
mov    %r13,%rsi
add    %rdi,%rsi
jne    19e0 <xml_escape_symbols+0x8c0>
cmp    %rdx,%r9
mov    0xc(%rsp),%r13d
lea    0x5fb(%rip),%r10
je     1162 <xml_escape_symbols+0x42>
test   $0xc,%r9b
je     1a9b <xml_escape_symbols+0x97b>
cmp    %rcx,%r12
cmovge %rcx,%r12
mov    %rax,%r10
sub    %r12,%r10
mov    %r10,%r11
and    $0xfffffffffffffffc,%r11
and    $0xfffffffffffffffc,%r9
neg    %r9
neg    %rdx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rbp,1),%r14
sub    %r11,%rbp
lea    (%rsi,%rax,1),%rdi
sub    %r11,%rax
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%rdx,1),%esi
mov    %esi,(%r14,%rdx,1)
add    $0xfffffffffffffffc,%rdx
cmp    %rdx,%r9
jne    1a50 <xml_escape_symbols+0x930>
cmp    %r11,%r10
mov    0x18(%rsp),%r14
lea    0x591(%rip),%r10
jne    1320 <xml_escape_symbols+0x200>
jmp    1162 <xml_escape_symbols+0x42>
sub    %rdx,%rbp
sub    %rdx,%rax
jmp    11f0 <xml_escape_symbols+0xd0>
sub    %rdx,%rbp
sub    %rdx,%rax
jmp    1260 <xml_escape_symbols+0x140>
sub    %rdx,%rbp
sub    %rdx,%rax
jmp    12c0 <xml_escape_symbols+0x1a0>
sub    %rdx,%rbp
sub    %rdx,%rax
jmp    1320 <xml_escape_symbols+0x200>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x5b8(%rip),%rdi
mov    %r13d,%esi
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <printf@plt>

LLVM IR (-O0):
@.str = [35 x i8] c"xml_Parse: MaxStrLen %d exceeded.\0A\00"
define void @xml_escape_symbols(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %3
store i32 %1, i32* %4
store i32 0, i32* %5
%9 = load i8*, i8** %3
%10 = call i32 @strlen(i8* %9)
store i32 %10, i32* %8
br label %11
11: ; preds = %262, %2
%12 = load i8*, i8** %3
%13 = load i32, i32* %5
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds i8, i8* %12, i64 %14
%16 = load i8, i8* %15
%17 = sext i8 %16 to i32
%18 = icmp eq i32 %17, 38
br i1 %18, label %19, label %71
19: ; preds = %11
%20 = load i32, i32* %8
%21 = add nsw i32 %20, 4
store i32 %21, i32* %6
%22 = load i32, i32* %8
store i32 %22, i32* %7
%23 = load i32, i32* %8
%24 = add nsw i32 %23, 4
store i32 %24, i32* %8
%25 = load i32, i32* %8
%26 = load i32, i32* %4
%27 = icmp sgt i32 %25, %26
br i1 %27, label %28, label %31
28: ; preds = %19
%29 = load i32, i32* %4
%30 = call i32 @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0), i32 %29)
br label %270
31: ; preds = %19
br label %32
32: ; preds = %44, %31
%33 = load i8*, i8** %3
%34 = load i32, i32* %7
%35 = add nsw i32 %34, -1
store i32 %35, i32* %7
%36 = sext i32 %34 to i64
%37 = getelementptr inbounds i8, i8* %33, i64 %36
%38 = load i8, i8* %37
%39 = load i8*, i8** %3
%40 = load i32, i32* %6
%41 = add nsw i32 %40, -1
store i32 %41, i32* %6
%42 = sext i32 %40 to i64
%43 = getelementptr inbounds i8, i8* %39, i64 %42
store i8 %38, i8* %43
br label %44
44: ; preds = %32
%45 = load i32, i32* %7
%46 = load i32, i32* %5
%47 = icmp sgt i32 %45, %46
br i1 %47, label %32, label %48
48: ; preds = %44
%49 = load i32, i32* %5
%50 = add nsw i32 %49, 1
store i32 %50, i32* %5
%51 = load i8*, i8** %3
%52 = load i32, i32* %5
%53 = add nsw i32 %52, 1
store i32 %53, i32* %5
%54 = sext i32 %52 to i64
%55 = getelementptr inbounds i8, i8* %51, i64 %54
store i8 97, i8* %55
%56 = load i8*, i8** %3
%57 = load i32, i32* %5
%58 = add nsw i32 %57, 1
store i32 %58, i32* %5
%59 = sext i32 %57 to i64
%60 = getelementptr inbounds i8, i8* %56, i64 %59
store i8 109, i8* %60
%61 = load i8*, i8** %3
%62 = load i32, i32* %5
%63 = add nsw i32 %62, 1
store i32 %63, i32* %5
%64 = sext i32 %62 to i64
%65 = getelementptr inbounds i8, i8* %61, i64 %64
store i8 112, i8* %65
%66 = load i8*, i8** %3
%67 = load i32, i32* %5
%68 = add nsw i32 %67, 1
store i32 %68, i32* %5
%69 = sext i32 %67 to i64
%70 = getelementptr inbounds i8, i8* %66, i64 %69
store i8 59, i8* %70
br label %261
71: ; preds = %11
%72 = load i8*, i8** %3
%73 = load i32, i32* %5
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %72, i64 %74
%76 = load i8, i8* %75
%77 = sext i8 %76 to i32
%78 = icmp eq i32 %77, 34
br i1 %78, label %79, label %139
79: ; preds = %71
%80 = load i32, i32* %8
%81 = add nsw i32 %80, 5
store i32 %81, i32* %6
%82 = load i32, i32* %8
store i32 %82, i32* %7
%83 = load i32, i32* %8
%84 = add nsw i32 %83, 5
store i32 %84, i32* %8
%85 = load i32, i32* %8
%86 = load i32, i32* %4
%87 = icmp sgt i32 %85, %86
br i1 %87, label %88, label %91
88: ; preds = %79
%89 = load i32, i32* %4
%90 = call i32 @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0), i32 %89)
br label %270
91: ; preds = %79
br label %92
92: ; preds = %104, %91
%93 = load i8*, i8** %3
%94 = load i32, i32* %7
%95 = add nsw i32 %94, -1
store i32 %95, i32* %7
%96 = sext i32 %94 to i64
%97 = getelementptr inbounds i8, i8* %93, i64 %96
%98 = load i8, i8* %97
%99 = load i8*, i8** %3
%100 = load i32, i32* %6
%101 = add nsw i32 %100, -1
store i32 %101, i32* %6
%102 = sext i32 %100 to i64
%103 = getelementptr inbounds i8, i8* %99, i64 %102
store i8 %98, i8* %103
br label %104
104: ; preds = %92
%105 = load i32, i32* %7
%106 = load i32, i32* %5
%107 = icmp sgt i32 %105, %106
br i1 %107, label %92, label %108
108: ; preds = %104
%109 = load i8*, i8** %3
%110 = load i32, i32* %5
%111 = add nsw i32 %110, 1
store i32 %111, i32* %5
%112 = sext i32 %110 to i64
%113 = getelementptr inbounds i8, i8* %109, i64 %112
store i8 38, i8* %113
%114 = load i8*, i8** %3
%115 = load i32, i32* %5
%116 = add nsw i32 %115, 1
store i32 %116, i32* %5
%117 = sext i32 %115 to i64
%118 = getelementptr inbounds i8, i8* %114, i64 %117
store i8 113, i8* %118
%119 = load i8*, i8** %3
%120 = load i32, i32* %5
%121 = add nsw i32 %120, 1
store i32 %121, i32* %5
%122 = sext i32 %120 to i64
%123 = getelementptr inbounds i8, i8* %119, i64 %122
store i8 117, i8* %123
%124 = load i8*, i8** %3
%125 = load i32, i32* %5
%126 = add nsw i32 %125, 1
store i32 %126, i32* %5
%127 = sext i32 %125 to i64
%128 = getelementptr inbounds i8, i8* %124, i64 %127
store i8 111, i8* %128
%129 = load i8*, i8** %3
%130 = load i32, i32* %5
%131 = add nsw i32 %130, 1
store i32 %131, i32* %5
%132 = sext i32 %130 to i64
%133 = getelementptr inbounds i8, i8* %129, i64 %132
store i8 116, i8* %133
%134 = load i8*, i8** %3
%135 = load i32, i32* %5
%136 = add nsw i32 %135, 1
store i32 %136, i32* %5
%137 = sext i32 %135 to i64
%138 = getelementptr inbounds i8, i8* %134, i64 %137
store i8 59, i8* %138
br label %260
139: ; preds = %71
%140 = load i8*, i8** %3
%141 = load i32, i32* %5
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %140, i64 %142
%144 = load i8, i8* %143
%145 = sext i8 %144 to i32
%146 = icmp eq i32 %145, 60
br i1 %146, label %147, label %197
147: ; preds = %139
%148 = load i32, i32* %8
%149 = add nsw i32 %148, 3
store i32 %149, i32* %6
%150 = load i32, i32* %8
store i32 %150, i32* %7
%151 = load i32, i32* %8
%152 = add nsw i32 %151, 3
store i32 %152, i32* %8
%153 = load i32, i32* %8
%154 = load i32, i32* %4
%155 = icmp sgt i32 %153, %154
br i1 %155, label %156, label %159
156: ; preds = %147
%157 = load i32, i32* %4
%158 = call i32 @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0), i32 %157)
br label %270
159: ; preds = %147
br label %160
160: ; preds = %172, %159
%161 = load i8*, i8** %3
%162 = load i32, i32* %7
%163 = add nsw i32 %162, -1
store i32 %163, i32* %7
%164 = sext i32 %162 to i64
%165 = getelementptr inbounds i8, i8* %161, i64 %164
%166 = load i8, i8* %165
%167 = load i8*, i8** %3
%168 = load i32, i32* %6
%169 = add nsw i32 %168, -1
store i32 %169, i32* %6
%170 = sext i32 %168 to i64
%171 = getelementptr inbounds i8, i8* %167, i64 %170
store i8 %166, i8* %171
br label %172
172: ; preds = %160
%173 = load i32, i32* %7
%174 = load i32, i32* %5
%175 = icmp sgt i32 %173, %174
br i1 %175, label %160, label %176
176: ; preds = %172
%177 = load i8*, i8** %3
%178 = load i32, i32* %5
%179 = add nsw i32 %178, 1
store i32 %179, i32* %5
%180 = sext i32 %178 to i64
%181 = getelementptr inbounds i8, i8* %177, i64 %180
store i8 38, i8* %181
%182 = load i8*, i8** %3
%183 = load i32, i32* %5
%184 = add nsw i32 %183, 1
store i32 %184, i32* %5
%185 = sext i32 %183 to i64
%186 = getelementptr inbounds i8, i8* %182, i64 %185
store i8 108, i8* %186
%187 = load i8*, i8** %3
%188 = load i32, i32* %5
%189 = add nsw i32 %188, 1
store i32 %189, i32* %5
%190 = sext i32 %188 to i64
%191 = getelementptr inbounds i8, i8* %187, i64 %190
store i8 116, i8* %191
%192 = load i8*, i8** %3
%193 = load i32, i32* %5
%194 = add nsw i32 %193, 1
store i32 %194, i32* %5
%195 = sext i32 %193 to i64
%196 = getelementptr inbounds i8, i8* %192, i64 %195
store i8 59, i8* %196
br label %259
197: ; preds = %139
%198 = load i8*, i8** %3
%199 = load i32, i32* %5
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i8, i8* %198, i64 %200
%202 = load i8, i8* %201
%203 = sext i8 %202 to i32
%204 = icmp eq i32 %203, 62
br i1 %204, label %205, label %255
205: ; preds = %197
%206 = load i32, i32* %8
%207 = add nsw i32 %206, 3
store i32 %207, i32* %6
%208 = load i32, i32* %8
store i32 %208, i32* %7
%209 = load i32, i32* %8
%210 = add nsw i32 %209, 3
store i32 %210, i32* %8
%211 = load i32, i32* %8
%212 = load i32, i32* %4
%213 = icmp sgt i32 %211, %212
br i1 %213, label %214, label %217
214: ; preds = %205
%215 = load i32, i32* %4
%216 = call i32 @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0), i32 %215)
br label %270
217: ; preds = %205
br label %218
218: ; preds = %230, %217
%219 = load i8*, i8** %3
%220 = load i32, i32* %7
%221 = add nsw i32 %220, -1
store i32 %221, i32* %7
%222 = sext i32 %220 to i64
%223 = getelementptr inbounds i8, i8* %219, i64 %222
%224 = load i8, i8* %223
%225 = load i8*, i8** %3
%226 = load i32, i32* %6
%227 = add nsw i32 %226, -1
store i32 %227, i32* %6
%228 = sext i32 %226 to i64
%229 = getelementptr inbounds i8, i8* %225, i64 %228
store i8 %224, i8* %229
br label %230
230: ; preds = %218
%231 = load i32, i32* %7
%232 = load i32, i32* %5
%233 = icmp sgt i32 %231, %232
br i1 %233, label %218, label %234
234: ; preds = %230
%235 = load i8*, i8** %3
%236 = load i32, i32* %5
%237 = add nsw i32 %236, 1
store i32 %237, i32* %5
%238 = sext i32 %236 to i64
%239 = getelementptr inbounds i8, i8* %235, i64 %238
store i8 38, i8* %239
%240 = load i8*, i8** %3
%241 = load i32, i32* %5
%242 = add nsw i32 %241, 1
store i32 %242, i32* %5
%243 = sext i32 %241 to i64
%244 = getelementptr inbounds i8, i8* %240, i64 %243
store i8 103, i8* %244
%245 = load i8*, i8** %3
%246 = load i32, i32* %5
%247 = add nsw i32 %246, 1
store i32 %247, i32* %5
%248 = sext i32 %246 to i64
%249 = getelementptr inbounds i8, i8* %245, i64 %248
store i8 116, i8* %249
%250 = load i8*, i8** %3
%251 = load i32, i32* %5
%252 = add nsw i32 %251, 1
store i32 %252, i32* %5
%253 = sext i32 %251 to i64
%254 = getelementptr inbounds i8, i8* %250, i64 %253
store i8 59, i8* %254
br label %258
255: ; preds = %197
%256 = load i32, i32* %5
%257 = add nsw i32 %256, 1
store i32 %257, i32* %5
br label %258
258: ; preds = %255, %234
br label %259
259: ; preds = %258, %176
br label %260
260: ; preds = %259, %108
br label %261
261: ; preds = %260, %48
br label %262
262: ; preds = %261
%263 = load i8*, i8** %3
%264 = load i32, i32* %5
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i8, i8* %263, i64 %265
%267 = load i8, i8* %266
%268 = sext i8 %267 to i32
%269 = icmp ne i32 %268, 0
br i1 %269, label %11, label %270
270: ; preds = %28, %88, %156, %214, %262
ret void
}

LLVM IR (-O2):
@.str = [35 x i8] c"xml_Parse: MaxStrLen %d exceeded.\0A\00"
define void @xml_escape_symbols(i8* %0, i32 %1) {
%3 = tail call i32 @strlen(i8* %0)
%4 = load i8, i8* %0
%5 = getelementptr i8, i8* %0, i64 1
%6 = getelementptr i8, i8* %0, i64 1
%7 = getelementptr i8, i8* %0, i64 1
%8 = getelementptr i8, i8* %0, i64 1
%9 = getelementptr i8, i8* %0, i64 1
%10 = getelementptr i8, i8* %0, i64 1
%11 = getelementptr i8, i8* %0, i64 1
%12 = getelementptr i8, i8* %0, i64 1
%13 = getelementptr i8, i8* %0, i64 1
%14 = getelementptr i8, i8* %0, i64 1
%15 = getelementptr i8, i8* %0, i64 1
%16 = getelementptr i8, i8* %0, i64 1
%17 = getelementptr i8, i8* %0, i64 1
%18 = getelementptr i8, i8* %0, i64 1
%19 = getelementptr i8, i8* %0, i64 1
%20 = getelementptr i8, i8* %0, i64 1
%21 = getelementptr inbounds i8, i8* %0, i64 -15
%22 = getelementptr inbounds i8, i8* %0, i64 -15
%23 = getelementptr inbounds i8, i8* %0, i64 -15
%24 = getelementptr inbounds i8, i8* %0, i64 -15
%25 = getelementptr inbounds i8, i8* %0, i64 -15
%26 = getelementptr inbounds i8, i8* %0, i64 -15
%27 = getelementptr inbounds i8, i8* %0, i64 -15
%28 = getelementptr inbounds i8, i8* %0, i64 -15
%29 = getelementptr inbounds i8, i8* %0, i64 -15
%30 = getelementptr inbounds i8, i8* %0, i64 -15
%31 = getelementptr inbounds i8, i8* %0, i64 -3
%32 = getelementptr inbounds i8, i8* %0, i64 -3
%33 = getelementptr inbounds i8, i8* %0, i64 -15
%34 = getelementptr inbounds i8, i8* %0, i64 -15
%35 = getelementptr inbounds i8, i8* %0, i64 -15
%36 = getelementptr inbounds i8, i8* %0, i64 -15
%37 = getelementptr inbounds i8, i8* %0, i64 -15
%38 = getelementptr inbounds i8, i8* %0, i64 -15
%39 = getelementptr inbounds i8, i8* %0, i64 -15
%40 = getelementptr inbounds i8, i8* %0, i64 -15
%41 = getelementptr inbounds i8, i8* %0, i64 -15
%42 = getelementptr inbounds i8, i8* %0, i64 -15
%43 = getelementptr inbounds i8, i8* %0, i64 -3
%44 = getelementptr inbounds i8, i8* %0, i64 -3
%45 = getelementptr inbounds i8, i8* %0, i64 -15
%46 = getelementptr inbounds i8, i8* %0, i64 -15
%47 = getelementptr inbounds i8, i8* %0, i64 -15
%48 = getelementptr inbounds i8, i8* %0, i64 -15
%49 = getelementptr inbounds i8, i8* %0, i64 -15
%50 = getelementptr inbounds i8, i8* %0, i64 -15
%51 = getelementptr inbounds i8, i8* %0, i64 -15
%52 = getelementptr inbounds i8, i8* %0, i64 -15
%53 = getelementptr inbounds i8, i8* %0, i64 -15
%54 = getelementptr inbounds i8, i8* %0, i64 -15
%55 = getelementptr inbounds i8, i8* %0, i64 -3
%56 = getelementptr inbounds i8, i8* %0, i64 -3
%57 = getelementptr inbounds i8, i8* %0, i64 -15
%58 = getelementptr inbounds i8, i8* %0, i64 -15
%59 = getelementptr inbounds i8, i8* %0, i64 -15
%60 = getelementptr inbounds i8, i8* %0, i64 -15
%61 = getelementptr inbounds i8, i8* %0, i64 -15
%62 = getelementptr inbounds i8, i8* %0, i64 -15
%63 = getelementptr inbounds i8, i8* %0, i64 -15
%64 = getelementptr inbounds i8, i8* %0, i64 -15
%65 = getelementptr inbounds i8, i8* %0, i64 -15
%66 = getelementptr inbounds i8, i8* %0, i64 -15
%67 = getelementptr inbounds i8, i8* %0, i64 -3
%68 = getelementptr inbounds i8, i8* %0, i64 -3
br label %69
69: ; preds = %675, %2
%70 = phi i8 [ %4, %2 ], [ %681, %675 ]
%71 = phi i32 [ 0, %2 ], [ %678, %675 ]
%72 = phi i32 [ %3, %2 ], [ %677, %675 ]
%73 = sext i32 %71 to i64
%74 = getelementptr inbounds i8, i8* %0, i64 %73
switch i8 %70, label %675 [
i8 38, label %75
i8 34, label %222
i8 60, label %372
i8 62, label %516
]
75: ; preds = %69
%76 = add i32 %72, 4
%77 = icmp sgt i32 %76, %1
br i1 %77, label %683, label %78
78: ; preds = %75
%79 = sext i32 %76 to i64
%80 = sext i32 %72 to i64
%81 = add nsw i64 %80, -1
%82 = call i64 @llvm.smin.i64(i64 %81, i64 %73)
%83 = sub i64 %80, %82
%84 = icmp ult i64 %83, 4
br i1 %84, label %205, label %85
85: ; preds = %78
%86 = add nsw i64 %80, -1
%87 = call i64 @llvm.smin.i64(i64 %86, i64 %73)
%88 = xor i64 %87, -1
%89 = add i64 %88, %80
%90 = getelementptr i8, i8* %0, i64 %79
%91 = sub i64 0, %89
%92 = getelementptr i8, i8* %90, i64 %91
%93 = icmp ugt i8* %92, %90
%94 = getelementptr i8, i8* %0, i64 %80
%95 = sub i64 0, %89
%96 = getelementptr i8, i8* %94, i64 %95
%97 = icmp ugt i8* %96, %94
%98 = or i1 %93, %97
br i1 %98, label %205, label %99
99: ; preds = %85
%100 = add nsw i64 %80, -1
%101 = call i64 @llvm.smin.i64(i64 %100, i64 %73)
%102 = add i64 %101, %79
%103 = sub i64 %102, %80
%104 = getelementptr i8, i8* %5, i64 %103
%105 = getelementptr i8, i8* %6, i64 %79
%106 = getelementptr i8, i8* %7, i64 %101
%107 = getelementptr i8, i8* %8, i64 %80
%108 = icmp ult i8* %104, %107
%109 = icmp ult i8* %106, %105
%110 = and i1 %108, %109
br i1 %110, label %205, label %111
111: ; preds = %99
%112 = icmp ult i64 %83, 16
br i1 %112, label %182, label %113
113: ; preds = %111
%114 = and i64 %83, -16
%115 = add i64 %114, -16
%116 = lshr exact i64 %115, 4
%117 = add nuw nsw i64 %116, 1
%118 = and i64 %117, 3
%119 = icmp ult i64 %115, 48
br i1 %119, label %159, label %120
120: ; preds = %113
%121 = and i64 %117, 2305843009213693948
br label %122
122: ; preds = %122, %120
%123 = phi i64 [ 0, %120 ], [ %156, %122 ]
%124 = phi i64 [ 0, %120 ], [ %157, %122 ]
%125 = sub i64 %80, %123
%126 = sub i64 %79, %123
%127 = getelementptr inbounds i8, i8* %57, i64 %125
%128 = bitcast i8* %127 to <16 x i8>*
%129 = load <16 x i8>, <16 x i8>* %128
%130 = getelementptr inbounds i8, i8* %58, i64 %126
%131 = bitcast i8* %130 to <16 x i8>*
store <16 x i8> %129, <16 x i8>* %131
%132 = or i64 %123, 16
%133 = sub i64 %80, %132
%134 = sub i64 %79, %132
%135 = getelementptr inbounds i8, i8* %59, i64 %133
%136 = bitcast i8* %135 to <16 x i8>*
%137 = load <16 x i8>, <16 x i8>* %136
%138 = getelementptr inbounds i8, i8* %60, i64 %134
%139 = bitcast i8* %138 to <16 x i8>*
store <16 x i8> %137, <16 x i8>* %139
%140 = or i64 %123, 32
%141 = sub i64 %80, %140
%142 = sub i64 %79, %140
%143 = getelementptr inbounds i8, i8* %61, i64 %141
%144 = bitcast i8* %143 to <16 x i8>*
%145 = load <16 x i8>, <16 x i8>* %144
%146 = getelementptr inbounds i8, i8* %62, i64 %142
%147 = bitcast i8* %146 to <16 x i8>*
store <16 x i8> %145, <16 x i8>* %147
%148 = or i64 %123, 48
%149 = sub i64 %80, %148
%150 = sub i64 %79, %148
%151 = getelementptr inbounds i8, i8* %63, i64 %149
%152 = bitcast i8* %151 to <16 x i8>*
%153 = load <16 x i8>, <16 x i8>* %152
%154 = getelementptr inbounds i8, i8* %64, i64 %150
%155 = bitcast i8* %154 to <16 x i8>*
store <16 x i8> %153, <16 x i8>* %155
%156 = add nuw i64 %123, 64
%157 = add i64 %124, 4
%158 = icmp eq i64 %157, %121
br i1 %158, label %159, label %122
159: ; preds = %122, %113
%160 = phi i64 [ 0, %113 ], [ %156, %122 ]
%161 = icmp eq i64 %118, 0
br i1 %161, label %175, label %162
162: ; preds = %159, %162
%163 = phi i64 [ %172, %162 ], [ %160, %159 ]
%164 = phi i64 [ %173, %162 ], [ 0, %159 ]
%165 = sub i64 %80, %163
%166 = sub i64 %79, %163
%167 = getelementptr inbounds i8, i8* %65, i64 %165
%168 = bitcast i8* %167 to <16 x i8>*
%169 = load <16 x i8>, <16 x i8>* %168
%170 = getelementptr inbounds i8, i8* %66, i64 %166
%171 = bitcast i8* %170 to <16 x i8>*
store <16 x i8> %169, <16 x i8>* %171
%172 = add nuw i64 %163, 16
%173 = add i64 %164, 1
%174 = icmp eq i64 %173, %118
br i1 %174, label %175, label %162
175: ; preds = %162, %159
%176 = icmp eq i64 %83, %114
br i1 %176, label %217, label %177
177: ; preds = %175
%178 = sub i64 %79, %114
%179 = sub i64 %80, %114
%180 = and i64 %83, 12
%181 = icmp eq i64 %180, 0
br i1 %181, label %205, label %182
182: ; preds = %111, %177
%183 = phi i64 [ %114, %177 ], [ 0, %111 ]
%184 = sext i32 %72 to i64
%185 = add nsw i64 %184, -1
%186 = sext i32 %71 to i64
%187 = call i64 @llvm.smin.i64(i64 %185, i64 %186)
%188 = sub i64 %184, %187
%189 = and i64 %188, -4
%190 = sub i64 %80, %189
%191 = sub i64 %79, %189
br label %192
192: ; preds = %192, %182
%193 = phi i64 [ %183, %182 ], [ %201, %192 ]
%194 = sub i64 %80, %193
%195 = sub i64 %79, %193
%196 = getelementptr inbounds i8, i8* %67, i64 %194
%197 = bitcast i8* %196 to <4 x i8>*
%198 = load <4 x i8>, <4 x i8>* %197
%199 = getelementptr inbounds i8, i8* %68, i64 %195
%200 = bitcast i8* %199 to <4 x i8>*
store <4 x i8> %198, <4 x i8>* %200
%201 = add nuw i64 %193, 4
%202 = icmp eq i64 %201, %189
br i1 %202, label %203, label %192
203: ; preds = %192
%204 = icmp eq i64 %188, %189
br i1 %204, label %217, label %205
205: ; preds = %99, %85, %78, %177, %203
%206 = phi i64 [ %80, %78 ], [ %80, %99 ], [ %80, %85 ], [ %179, %177 ], [ %190, %203 ]
%207 = phi i64 [ %79, %78 ], [ %79, %99 ], [ %79, %85 ], [ %178, %177 ], [ %191, %203 ]
br label %208
208: ; preds = %205, %208
%209 = phi i64 [ %211, %208 ], [ %206, %205 ]
%210 = phi i64 [ %214, %208 ], [ %207, %205 ]
%211 = add nsw i64 %209, -1
%212 = getelementptr inbounds i8, i8* %0, i64 %209
%213 = load i8, i8* %212
%214 = add nsw i64 %210, -1
%215 = getelementptr inbounds i8, i8* %0, i64 %210
store i8 %213, i8* %215
%216 = icmp sgt i64 %211, %73
br i1 %216, label %208, label %217
217: ; preds = %208, %203, %175
%218 = add nsw i32 %71, 1
%219 = add nsw i32 %71, 2
%220 = sext i32 %218 to i64
%221 = getelementptr inbounds i8, i8* %0, i64 %220
store i8 97, i8* %221
br label %660
222: ; preds = %69
%223 = add i32 %72, 5
%224 = icmp sgt i32 %223, %1
br i1 %224, label %683, label %225
225: ; preds = %222
%226 = sext i32 %223 to i64
%227 = sext i32 %72 to i64
%228 = add nsw i64 %227, -1
%229 = call i64 @llvm.smin.i64(i64 %228, i64 %73)
%230 = sub i64 %227, %229
%231 = icmp ult i64 %230, 4
br i1 %231, label %352, label %232
232: ; preds = %225
%233 = add nsw i64 %227, -1
%234 = call i64 @llvm.smin.i64(i64 %233, i64 %73)
%235 = xor i64 %234, -1
%236 = add i64 %235, %227
%237 = getelementptr i8, i8* %0, i64 %226
%238 = sub i64 0, %236
%239 = getelementptr i8, i8* %237, i64 %238
%240 = icmp ugt i8* %239, %237
%241 = getelementptr i8, i8* %0, i64 %227
%242 = sub i64 0, %236
%243 = getelementptr i8, i8* %241, i64 %242
%244 = icmp ugt i8* %243, %241
%245 = or i1 %240, %244
br i1 %245, label %352, label %246
246: ; preds = %232
%247 = add nsw i64 %227, -1
%248 = call i64 @llvm.smin.i64(i64 %247, i64 %73)
%249 = add i64 %248, %226
%250 = sub i64 %249, %227
%251 = getelementptr i8, i8* %9, i64 %250
%252 = getelementptr i8, i8* %10, i64 %226
%253 = getelementptr i8, i8* %11, i64 %248
%254 = getelementptr i8, i8* %12, i64 %227
%255 = icmp ult i8* %251, %254
%256 = icmp ult i8* %253, %252
%257 = and i1 %255, %256
br i1 %257, label %352, label %258
258: ; preds = %246
%259 = icmp ult i64 %230, 16
br i1 %259, label %329, label %260
260: ; preds = %258
%261 = and i64 %230, -16
%262 = add i64 %261, -16
%263 = lshr exact i64 %262, 4
%264 = add nuw nsw i64 %263, 1
%265 = and i64 %264, 3
%266 = icmp ult i64 %262, 48
br i1 %266, label %306, label %267
267: ; preds = %260
%268 = and i64 %264, 2305843009213693948
br label %269
269: ; preds = %269, %267
%270 = phi i64 [ 0, %267 ], [ %303, %269 ]
%271 = phi i64 [ 0, %267 ], [ %304, %269 ]
%272 = sub i64 %227, %270
%273 = sub i64 %226, %270
%274 = getelementptr inbounds i8, i8* %45, i64 %272
%275 = bitcast i8* %274 to <16 x i8>*
%276 = load <16 x i8>, <16 x i8>* %275
%277 = getelementptr inbounds i8, i8* %46, i64 %273
%278 = bitcast i8* %277 to <16 x i8>*
store <16 x i8> %276, <16 x i8>* %278
%279 = or i64 %270, 16
%280 = sub i64 %227, %279
%281 = sub i64 %226, %279
%282 = getelementptr inbounds i8, i8* %47, i64 %280
%283 = bitcast i8* %282 to <16 x i8>*
%284 = load <16 x i8>, <16 x i8>* %283
%285 = getelementptr inbounds i8, i8* %48, i64 %281
%286 = bitcast i8* %285 to <16 x i8>*
store <16 x i8> %284, <16 x i8>* %286
%287 = or i64 %270, 32
%288 = sub i64 %227, %287
%289 = sub i64 %226, %287
%290 = getelementptr inbounds i8, i8* %49, i64 %288
%291 = bitcast i8* %290 to <16 x i8>*
%292 = load <16 x i8>, <16 x i8>* %291
%293 = getelementptr inbounds i8, i8* %50, i64 %289
%294 = bitcast i8* %293 to <16 x i8>*
store <16 x i8> %292, <16 x i8>* %294
%295 = or i64 %270, 48
%296 = sub i64 %227, %295
%297 = sub i64 %226, %295
%298 = getelementptr inbounds i8, i8* %51, i64 %296
%299 = bitcast i8* %298 to <16 x i8>*
%300 = load <16 x i8>, <16 x i8>* %299
%301 = getelementptr inbounds i8, i8* %52, i64 %297
%302 = bitcast i8* %301 to <16 x i8>*
store <16 x i8> %300, <16 x i8>* %302
%303 = add nuw i64 %270, 64
%304 = add i64 %271, 4
%305 = icmp eq i64 %304, %268
br i1 %305, label %306, label %269
306: ; preds = %269, %260
%307 = phi i64 [ 0, %260 ], [ %303, %269 ]
%308 = icmp eq i64 %265, 0
br i1 %308, label %322, label %309
309: ; preds = %306, %309
%310 = phi i64 [ %319, %309 ], [ %307, %306 ]
%311 = phi i64 [ %320, %309 ], [ 0, %306 ]
%312 = sub i64 %227, %310
%313 = sub i64 %226, %310
%314 = getelementptr inbounds i8, i8* %53, i64 %312
%315 = bitcast i8* %314 to <16 x i8>*
%316 = load <16 x i8>, <16 x i8>* %315
%317 = getelementptr inbounds i8, i8* %54, i64 %313
%318 = bitcast i8* %317 to <16 x i8>*
store <16 x i8> %316, <16 x i8>* %318
%319 = add nuw i64 %310, 16
%320 = add i64 %311, 1
%321 = icmp eq i64 %320, %265
br i1 %321, label %322, label %309
322: ; preds = %309, %306
%323 = icmp eq i64 %230, %261
br i1 %323, label %364, label %324
324: ; preds = %322
%325 = sub i64 %226, %261
%326 = sub i64 %227, %261
%327 = and i64 %230, 12
%328 = icmp eq i64 %327, 0
br i1 %328, label %352, label %329
329: ; preds = %258, %324
%330 = phi i64 [ %261, %324 ], [ 0, %258 ]
%331 = sext i32 %72 to i64
%332 = add nsw i64 %331, -1
%333 = sext i32 %71 to i64
%334 = call i64 @llvm.smin.i64(i64 %332, i64 %333)
%335 = sub i64 %331, %334
%336 = and i64 %335, -4
%337 = sub i64 %227, %336
%338 = sub i64 %226, %336
br label %339
339: ; preds = %339, %329
%340 = phi i64 [ %330, %329 ], [ %348, %339 ]
%341 = sub i64 %227, %340
%342 = sub i64 %226, %340
%343 = getelementptr inbounds i8, i8* %55, i64 %341
%344 = bitcast i8* %343 to <4 x i8>*
%345 = load <4 x i8>, <4 x i8>* %344
%346 = getelementptr inbounds i8, i8* %56, i64 %342
%347 = bitcast i8* %346 to <4 x i8>*
store <4 x i8> %345, <4 x i8>* %347
%348 = add nuw i64 %340, 4
%349 = icmp eq i64 %348, %336
br i1 %349, label %350, label %339
350: ; preds = %339
%351 = icmp eq i64 %335, %336
br i1 %351, label %364, label %352
352: ; preds = %246, %232, %225, %324, %350
%353 = phi i64 [ %227, %225 ], [ %227, %246 ], [ %227, %232 ], [ %326, %324 ], [ %337, %350 ]
%354 = phi i64 [ %226, %225 ], [ %226, %246 ], [ %226, %232 ], [ %325, %324 ], [ %338, %350 ]
br label %355
355: ; preds = %352, %355
%356 = phi i64 [ %358, %355 ], [ %353, %352 ]
%357 = phi i64 [ %361, %355 ], [ %354, %352 ]
%358 = add nsw i64 %356, -1
%359 = getelementptr inbounds i8, i8* %0, i64 %356
%360 = load i8, i8* %359
%361 = add nsw i64 %357, -1
%362 = getelementptr inbounds i8, i8* %0, i64 %357
store i8 %360, i8* %362
%363 = icmp sgt i64 %358, %73
br i1 %363, label %355, label %364
364: ; preds = %355, %350, %322
%365 = add nsw i32 %71, 1
store i8 38, i8* %74
%366 = add nsw i32 %71, 2
%367 = sext i32 %365 to i64
%368 = getelementptr inbounds i8, i8* %0, i64 %367
store i8 113, i8* %368
%369 = add nsw i32 %71, 3
%370 = sext i32 %366 to i64
%371 = getelementptr inbounds i8, i8* %0, i64 %370
store i8 117, i8* %371
br label %660
372: ; preds = %69
%373 = add i32 %72, 3
%374 = icmp sgt i32 %373, %1
br i1 %374, label %683, label %375
375: ; preds = %372
%376 = sext i32 %373 to i64
%377 = sext i32 %72 to i64
%378 = add nsw i64 %377, -1
%379 = call i64 @llvm.smin.i64(i64 %378, i64 %73)
%380 = sub i64 %377, %379
%381 = icmp ult i64 %380, 4
br i1 %381, label %502, label %382
382: ; preds = %375
%383 = add nsw i64 %377, -1
%384 = call i64 @llvm.smin.i64(i64 %383, i64 %73)
%385 = xor i64 %384, -1
%386 = add i64 %385, %377
%387 = getelementptr i8, i8* %0, i64 %376
%388 = sub i64 0, %386
%389 = getelementptr i8, i8* %387, i64 %388
%390 = icmp ugt i8* %389, %387
%391 = getelementptr i8, i8* %0, i64 %377
%392 = sub i64 0, %386
%393 = getelementptr i8, i8* %391, i64 %392
%394 = icmp ugt i8* %393, %391
%395 = or i1 %390, %394
br i1 %395, label %502, label %396
396: ; preds = %382
%397 = add nsw i64 %377, -1
%398 = call i64 @llvm.smin.i64(i64 %397, i64 %73)
%399 = add i64 %398, %376
%400 = sub i64 %399, %377
%401 = getelementptr i8, i8* %13, i64 %400
%402 = getelementptr i8, i8* %14, i64 %376
%403 = getelementptr i8, i8* %15, i64 %398
%404 = getelementptr i8, i8* %16, i64 %377
%405 = icmp ult i8* %401, %404
%406 = icmp ult i8* %403, %402
%407 = and i1 %405, %406
br i1 %407, label %502, label %408
408: ; preds = %396
%409 = icmp ult i64 %380, 16
br i1 %409, label %479, label %410
410: ; preds = %408
%411 = and i64 %380, -16
%412 = add i64 %411, -16
%413 = lshr exact i64 %412, 4
%414 = add nuw nsw i64 %413, 1
%415 = and i64 %414, 3
%416 = icmp ult i64 %412, 48
br i1 %416, label %456, label %417
417: ; preds = %410
%418 = and i64 %414, 2305843009213693948
br label %419
419: ; preds = %419, %417
%420 = phi i64 [ 0, %417 ], [ %453, %419 ]
%421 = phi i64 [ 0, %417 ], [ %454, %419 ]
%422 = sub i64 %377, %420
%423 = sub i64 %376, %420
%424 = getelementptr inbounds i8, i8* %33, i64 %422
%425 = bitcast i8* %424 to <16 x i8>*
%426 = load <16 x i8>, <16 x i8>* %425
%427 = getelementptr inbounds i8, i8* %34, i64 %423
%428 = bitcast i8* %427 to <16 x i8>*
store <16 x i8> %426, <16 x i8>* %428
%429 = or i64 %420, 16
%430 = sub i64 %377, %429
%431 = sub i64 %376, %429
%432 = getelementptr inbounds i8, i8* %35, i64 %430
%433 = bitcast i8* %432 to <16 x i8>*
%434 = load <16 x i8>, <16 x i8>* %433
%435 = getelementptr inbounds i8, i8* %36, i64 %431
%436 = bitcast i8* %435 to <16 x i8>*
store <16 x i8> %434, <16 x i8>* %436
%437 = or i64 %420, 32
%438 = sub i64 %377, %437
%439 = sub i64 %376, %437
%440 = getelementptr inbounds i8, i8* %37, i64 %438
%441 = bitcast i8* %440 to <16 x i8>*
%442 = load <16 x i8>, <16 x i8>* %441
%443 = getelementptr inbounds i8, i8* %38, i64 %439
%444 = bitcast i8* %443 to <16 x i8>*
store <16 x i8> %442, <16 x i8>* %444
%445 = or i64 %420, 48
%446 = sub i64 %377, %445
%447 = sub i64 %376, %445
%448 = getelementptr inbounds i8, i8* %39, i64 %446
%449 = bitcast i8* %448 to <16 x i8>*
%450 = load <16 x i8>, <16 x i8>* %449
%451 = getelementptr inbounds i8, i8* %40, i64 %447
%452 = bitcast i8* %451 to <16 x i8>*
store <16 x i8> %450, <16 x i8>* %452
%453 = add nuw i64 %420, 64
%454 = add i64 %421, 4
%455 = icmp eq i64 %454, %418
br i1 %455, label %456, label %419
456: ; preds = %419, %410
%457 = phi i64 [ 0, %410 ], [ %453, %419 ]
%458 = icmp eq i64 %415, 0
br i1 %458, label %472, label %459
459: ; preds = %456, %459
%460 = phi i64 [ %469, %459 ], [ %457, %456 ]
%461 = phi i64 [ %470, %459 ], [ 0, %456 ]
%462 = sub i64 %377, %460
%463 = sub i64 %376, %460
%464 = getelementptr inbounds i8, i8* %41, i64 %462
%465 = bitcast i8* %464 to <16 x i8>*
%466 = load <16 x i8>, <16 x i8>* %465
%467 = getelementptr inbounds i8, i8* %42, i64 %463
%468 = bitcast i8* %467 to <16 x i8>*
store <16 x i8> %466, <16 x i8>* %468
%469 = add nuw i64 %460, 16
%470 = add i64 %461, 1
%471 = icmp eq i64 %470, %415
br i1 %471, label %472, label %459
472: ; preds = %459, %456
%473 = icmp eq i64 %380, %411
br i1 %473, label %514, label %474
474: ; preds = %472
%475 = sub i64 %376, %411
%476 = sub i64 %377, %411
%477 = and i64 %380, 12
%478 = icmp eq i64 %477, 0
br i1 %478, label %502, label %479
479: ; preds = %408, %474
%480 = phi i64 [ %411, %474 ], [ 0, %408 ]
%481 = sext i32 %72 to i64
%482 = add nsw i64 %481, -1
%483 = sext i32 %71 to i64
%484 = call i64 @llvm.smin.i64(i64 %482, i64 %483)
%485 = sub i64 %481, %484
%486 = and i64 %485, -4
%487 = sub i64 %377, %486
%488 = sub i64 %376, %486
br label %489
489: ; preds = %489, %479
%490 = phi i64 [ %480, %479 ], [ %498, %489 ]
%491 = sub i64 %377, %490
%492 = sub i64 %376, %490
%493 = getelementptr inbounds i8, i8* %43, i64 %491
%494 = bitcast i8* %493 to <4 x i8>*
%495 = load <4 x i8>, <4 x i8>* %494
%496 = getelementptr inbounds i8, i8* %44, i64 %492
%497 = bitcast i8* %496 to <4 x i8>*
store <4 x i8> %495, <4 x i8>* %497
%498 = add nuw i64 %490, 4
%499 = icmp eq i64 %498, %486
br i1 %499, label %500, label %489
500: ; preds = %489
%501 = icmp eq i64 %485, %486
br i1 %501, label %514, label %502
502: ; preds = %396, %382, %375, %474, %500
%503 = phi i64 [ %377, %375 ], [ %377, %396 ], [ %377, %382 ], [ %476, %474 ], [ %487, %500 ]
%504 = phi i64 [ %376, %375 ], [ %376, %396 ], [ %376, %382 ], [ %475, %474 ], [ %488, %500 ]
br label %505
505: ; preds = %502, %505
%506 = phi i64 [ %508, %505 ], [ %503, %502 ]
%507 = phi i64 [ %511, %505 ], [ %504, %502 ]
%508 = add nsw i64 %506, -1
%509 = getelementptr inbounds i8, i8* %0, i64 %506
%510 = load i8, i8* %509
%511 = add nsw i64 %507, -1
%512 = getelementptr inbounds i8, i8* %0, i64 %507
store i8 %510, i8* %512
%513 = icmp sgt i64 %508, %73
br i1 %513, label %505, label %514
514: ; preds = %505, %500, %472
%515 = add nsw i32 %71, 1
store i8 38, i8* %74
br label %660
516: ; preds = %69
%517 = add i32 %72, 3
%518 = icmp sgt i32 %517, %1
br i1 %518, label %683, label %519
519: ; preds = %516
%520 = sext i32 %517 to i64
%521 = sext i32 %72 to i64
%522 = add nsw i64 %521, -1
%523 = call i64 @llvm.smin.i64(i64 %522, i64 %73)
%524 = sub i64 %521, %523
%525 = icmp ult i64 %524, 4
br i1 %525, label %646, label %526
526: ; preds = %519
%527 = add nsw i64 %521, -1
%528 = call i64 @llvm.smin.i64(i64 %527, i64 %73)
%529 = xor i64 %528, -1
%530 = add i64 %529, %521
%531 = getelementptr i8, i8* %0, i64 %520
%532 = sub i64 0, %530
%533 = getelementptr i8, i8* %531, i64 %532
%534 = icmp ugt i8* %533, %531
%535 = getelementptr i8, i8* %0, i64 %521
%536 = sub i64 0, %530
%537 = getelementptr i8, i8* %535, i64 %536
%538 = icmp ugt i8* %537, %535
%539 = or i1 %534, %538
br i1 %539, label %646, label %540
540: ; preds = %526
%541 = add nsw i64 %521, -1
%542 = call i64 @llvm.smin.i64(i64 %541, i64 %73)
%543 = add i64 %542, %520
%544 = sub i64 %543, %521
%545 = getelementptr i8, i8* %17, i64 %544
%546 = getelementptr i8, i8* %18, i64 %520
%547 = getelementptr i8, i8* %19, i64 %542
%548 = getelementptr i8, i8* %20, i64 %521
%549 = icmp ult i8* %545, %548
%550 = icmp ult i8* %547, %546
%551 = and i1 %549, %550
br i1 %551, label %646, label %552
552: ; preds = %540
%553 = icmp ult i64 %524, 16
br i1 %553, label %623, label %554
554: ; preds = %552
%555 = and i64 %524, -16
%556 = add i64 %555, -16
%557 = lshr exact i64 %556, 4
%558 = add nuw nsw i64 %557, 1
%559 = and i64 %558, 3
%560 = icmp ult i64 %556, 48
br i1 %560, label %600, label %561
561: ; preds = %554
%562 = and i64 %558, 2305843009213693948
br label %563
563: ; preds = %563, %561
%564 = phi i64 [ 0, %561 ], [ %597, %563 ]
%565 = phi i64 [ 0, %561 ], [ %598, %563 ]
%566 = sub i64 %521, %564
%567 = sub i64 %520, %564
%568 = getelementptr inbounds i8, i8* %21, i64 %566
%569 = bitcast i8* %568 to <16 x i8>*
%570 = load <16 x i8>, <16 x i8>* %569
%571 = getelementptr inbounds i8, i8* %22, i64 %567
%572 = bitcast i8* %571 to <16 x i8>*
store <16 x i8> %570, <16 x i8>* %572
%573 = or i64 %564, 16
%574 = sub i64 %521, %573
%575 = sub i64 %520, %573
%576 = getelementptr inbounds i8, i8* %23, i64 %574
%577 = bitcast i8* %576 to <16 x i8>*
%578 = load <16 x i8>, <16 x i8>* %577
%579 = getelementptr inbounds i8, i8* %24, i64 %575
%580 = bitcast i8* %579 to <16 x i8>*
store <16 x i8> %578, <16 x i8>* %580
%581 = or i64 %564, 32
%582 = sub i64 %521, %581
%583 = sub i64 %520, %581
%584 = getelementptr inbounds i8, i8* %25, i64 %582
%585 = bitcast i8* %584 to <16 x i8>*
%586 = load <16 x i8>, <16 x i8>* %585
%587 = getelementptr inbounds i8, i8* %26, i64 %583
%588 = bitcast i8* %587 to <16 x i8>*
store <16 x i8> %586, <16 x i8>* %588
%589 = or i64 %564, 48
%590 = sub i64 %521, %589
%591 = sub i64 %520, %589
%592 = getelementptr inbounds i8, i8* %27, i64 %590
%593 = bitcast i8* %592 to <16 x i8>*
%594 = load <16 x i8>, <16 x i8>* %593
%595 = getelementptr inbounds i8, i8* %28, i64 %591
%596 = bitcast i8* %595 to <16 x i8>*
store <16 x i8> %594, <16 x i8>* %596
%597 = add nuw i64 %564, 64
%598 = add i64 %565, 4
%599 = icmp eq i64 %598, %562
br i1 %599, label %600, label %563
600: ; preds = %563, %554
%601 = phi i64 [ 0, %554 ], [ %597, %563 ]
%602 = icmp eq i64 %559, 0
br i1 %602, label %616, label %603
603: ; preds = %600, %603
%604 = phi i64 [ %613, %603 ], [ %601, %600 ]
%605 = phi i64 [ %614, %603 ], [ 0, %600 ]
%606 = sub i64 %521, %604
%607 = sub i64 %520, %604
%608 = getelementptr inbounds i8, i8* %29, i64 %606
%609 = bitcast i8* %608 to <16 x i8>*
%610 = load <16 x i8>, <16 x i8>* %609
%611 = getelementptr inbounds i8, i8* %30, i64 %607
%612 = bitcast i8* %611 to <16 x i8>*
store <16 x i8> %610, <16 x i8>* %612
%613 = add nuw i64 %604, 16
%614 = add i64 %605, 1
%615 = icmp eq i64 %614, %559
br i1 %615, label %616, label %603
616: ; preds = %603, %600
%617 = icmp eq i64 %524, %555
br i1 %617, label %658, label %618
618: ; preds = %616
%619 = sub i64 %520, %555
%620 = sub i64 %521, %555
%621 = and i64 %524, 12
%622 = icmp eq i64 %621, 0
br i1 %622, label %646, label %623
623: ; preds = %552, %618
%624 = phi i64 [ %555, %618 ], [ 0, %552 ]
%625 = sext i32 %72 to i64
%626 = add nsw i64 %625, -1
%627 = sext i32 %71 to i64
%628 = call i64 @llvm.smin.i64(i64 %626, i64 %627)
%629 = sub i64 %625, %628
%630 = and i64 %629, -4
%631 = sub i64 %521, %630
%632 = sub i64 %520, %630
br label %633
633: ; preds = %633, %623
%634 = phi i64 [ %624, %623 ], [ %642, %633 ]
%635 = sub i64 %521, %634
%636 = sub i64 %520, %634
%637 = getelementptr inbounds i8, i8* %31, i64 %635
%638 = bitcast i8* %637 to <4 x i8>*
%639 = load <4 x i8>, <4 x i8>* %638
%640 = getelementptr inbounds i8, i8* %32, i64 %636
%641 = bitcast i8* %640 to <4 x i8>*
store <4 x i8> %639, <4 x i8>* %641
%642 = add nuw i64 %634, 4
%643 = icmp eq i64 %642, %630
br i1 %643, label %644, label %633
644: ; preds = %633
%645 = icmp eq i64 %629, %630
br i1 %645, label %658, label %646
646: ; preds = %540, %526, %519, %618, %644
%647 = phi i64 [ %521, %519 ], [ %521, %540 ], [ %521, %526 ], [ %620, %618 ], [ %631, %644 ]
%648 = phi i64 [ %520, %519 ], [ %520, %540 ], [ %520, %526 ], [ %619, %618 ], [ %632, %644 ]
br label %649
649: ; preds = %646, %649
%650 = phi i64 [ %652, %649 ], [ %647, %646 ]
%651 = phi i64 [ %655, %649 ], [ %648, %646 ]
%652 = add nsw i64 %650, -1
%653 = getelementptr inbounds i8, i8* %0, i64 %650
%654 = load i8, i8* %653
%655 = add nsw i64 %651, -1
%656 = getelementptr inbounds i8, i8* %0, i64 %651
store i8 %654, i8* %656
%657 = icmp sgt i64 %652, %73
br i1 %657, label %649, label %658
658: ; preds = %649, %644, %616
%659 = add nsw i32 %71, 1
store i8 38, i8* %74
br label %660
660: ; preds = %364, %658, %514, %217
%661 = phi i32 [ 4, %364 ], [ 2, %658 ], [ 2, %514 ], [ 3, %217 ]
%662 = phi i32 [ %369, %364 ], [ %659, %658 ], [ %515, %514 ], [ %219, %217 ]
%663 = phi i8 [ 111, %364 ], [ 103, %658 ], [ 108, %514 ], [ 109, %217 ]
%664 = phi i32 [ 5, %364 ], [ 3, %658 ], [ 3, %514 ], [ 4, %217 ]
%665 = phi i8 [ 116, %364 ], [ 116, %658 ], [ 116, %514 ], [ 112, %217 ]
%666 = phi i32 [ %223, %364 ], [ %517, %658 ], [ %373, %514 ], [ %76, %217 ]
%667 = add nsw i32 %71, %661
%668 = sext i32 %662 to i64
%669 = getelementptr inbounds i8, i8* %0, i64 %668
store i8 %663, i8* %669
%670 = add nsw i32 %71, %664
%671 = sext i32 %667 to i64
%672 = getelementptr inbounds i8, i8* %0, i64 %671
store i8 %665, i8* %672
%673 = sext i32 %670 to i64
%674 = getelementptr inbounds i8, i8* %0, i64 %673
store i8 59, i8* %674
br label %675
675: ; preds = %660, %69
%676 = phi i32 [ %71, %69 ], [ %670, %660 ]
%677 = phi i32 [ %72, %69 ], [ %666, %660 ]
%678 = add nsw i32 %676, 1
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds i8, i8* %0, i64 %679
%681 = load i8, i8* %680
%682 = icmp eq i8 %681, 0
br i1 %682, label %685, label %69
683: ; preds = %516, %372, %222, %75
%684 = tail call i32 @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0), i32 %1)
br label %685
685: ; preds = %675, %683
ret void
}