#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 */
typedef int /*<<< orphan*/ tmpbuf3;
typedef int /*<<< orphan*/ tmpbuf2;
typedef int /*<<< orphan*/ tmpbuf1;

/* Variables and functions */
scalar_t__ isspace(char const);
int /*<<< orphan*/ snprintf(char *, int, char *, char const *);
int strlen(char const *);
char *strstr(char const *, char *);
const char *xmlq(const char *s, int idx, const char *name, char *dstbuf,
                 int dstlen) {
  const char *save_s = s;
  if (!s || !name || !dstbuf || !dstlen)
    return NULL;
  *dstbuf = 0;
  if (strlen(name) >= 1024)
    return NULL;
  char tmpbuf1[1024 + 10], tmpbuf2[1024 + 10], tmpbuf3[1024 + 10];
  char *dst = dstbuf;
  int i = 0;
  while (isspace(*s))
    s++;
  if (*s != '<')
    return NULL;
  snprintf(tmpbuf1, sizeof(tmpbuf1), "<%s>", name);
  snprintf(tmpbuf2, sizeof(tmpbuf2), "<%s ", name);
  snprintf(tmpbuf3, sizeof(tmpbuf3), "</%s>", name);
  const char *ptr = NULL, *ptr3;
  while (i++ <= idx) {
    ptr = strstr(s, tmpbuf1);
    if (!ptr) {
      ptr = strstr(s, tmpbuf2);
      if (!ptr)
        return NULL;
      while (*ptr != '>')
        ptr++;
      ptr++;
    } else
      ptr += strlen(tmpbuf1);
    s = ptr + 1;
  }
  ptr3 = strstr(ptr, tmpbuf3);
  if (!ptr3)
    ptr3 = save_s + strlen(save_s);
  while (isspace(*ptr))
    ptr++;
  while (ptr != ptr3)
    *dst++ = *ptr++;
  while ((dst != dstbuf) && isspace(dst[-1]))
    dst--;
  *dst = 0;
  return dstbuf;
}


x86 assembly (clang, -O0):
<xmlq>:
push   %rbp
mov    %rsp,%rbp
sub    $0xca0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1191 <xmlq+0x51>
cmpq   $0x0,-0x20(%rbp)
je     1191 <xmlq+0x51>
cmpq   $0x0,-0x28(%rbp)
je     1191 <xmlq+0x51>
cmpl   $0x0,-0x2c(%rbp)
jne    119e <xmlq+0x5e>
movq   $0x0,-0x8(%rbp)
jmp    14b5 <xmlq+0x375>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rdi
call   1030 <strlen@plt>
cmp    $0x400,%eax
jl     11c6 <xmlq+0x86>
movq   $0x0,-0x8(%rbp)
jmp    14b5 <xmlq+0x375>
mov    -0x28(%rbp),%rax
mov    %rax,-0xc78(%rbp)
movl   $0x0,-0xc7c(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%rax
je     1202 <xmlq+0xc2>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11db <xmlq+0x9b>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3c,%eax
je     121f <xmlq+0xdf>
movq   $0x0,-0x8(%rbp)
jmp    14b5 <xmlq+0x375>
lea    -0x450(%rbp),%rdi
mov    -0x20(%rbp),%rcx
mov    $0x40a,%esi
lea    0xdca(%rip),%rdx
call   1040 <snprintf@plt>
lea    -0x860(%rbp),%rdi
mov    -0x20(%rbp),%rcx
mov    $0x40a,%esi
lea    0xdb3(%rip),%rdx
call   1040 <snprintf@plt>
lea    -0xc70(%rbp),%rdi
mov    -0x20(%rbp),%rcx
mov    $0x40a,%esi
lea    0xd9c(%rip),%rdx
call   1040 <snprintf@plt>
movq   $0x0,-0xc88(%rbp)
mov    -0xc7c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xc7c(%rbp)
cmp    -0x14(%rbp),%eax
jg     136b <xmlq+0x22b>
mov    -0x10(%rbp),%rdi
lea    -0x450(%rbp),%rsi
call   1060 <strstr@plt>
mov    %rax,-0xc88(%rbp)
cmpq   $0x0,-0xc88(%rbp)
jne    1335 <xmlq+0x1f5>
mov    -0x10(%rbp),%rdi
lea    -0x860(%rbp),%rsi
call   1060 <strstr@plt>
mov    %rax,-0xc88(%rbp)
cmpq   $0x0,-0xc88(%rbp)
jne    12ef <xmlq+0x1af>
movq   $0x0,-0x8(%rbp)
jmp    14b5 <xmlq+0x375>
jmp    12f4 <xmlq+0x1b4>
mov    -0xc88(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3e,%eax
je     131e <xmlq+0x1de>
mov    -0xc88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc88(%rbp)
jmp    12f4 <xmlq+0x1b4>
mov    -0xc88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc88(%rbp)
jmp    1357 <xmlq+0x217>
lea    -0x450(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0xc88(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0xc88(%rbp)
mov    -0xc88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    127e <xmlq+0x13e>
mov    -0xc88(%rbp),%rdi
lea    -0xc70(%rbp),%rsi
call   1060 <strstr@plt>
mov    %rax,-0xc90(%rbp)
cmpq   $0x0,-0xc90(%rbp)
jne    13bd <xmlq+0x27d>
mov    -0x38(%rbp),%rax
mov    %rax,-0xc98(%rbp)
mov    -0x38(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0xc98(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0xc90(%rbp)
jmp    13c2 <xmlq+0x282>
mov    -0xc88(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%rax
je     13f2 <xmlq+0x2b2>
mov    -0xc88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc88(%rbp)
jmp    13c2 <xmlq+0x282>
jmp    13f7 <xmlq+0x2b7>
mov    -0xc88(%rbp),%rax
cmp    -0xc90(%rbp),%rax
je     143e <xmlq+0x2fe>
mov    -0xc88(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0xc88(%rbp)
mov    (%rax),%cl
mov    -0xc78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0xc78(%rbp)
mov    %cl,(%rax)
jmp    13f7 <xmlq+0x2b7>
jmp    1443 <xmlq+0x303>
mov    -0xc78(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0xc99(%rbp)
je     1479 <xmlq+0x339>
mov    -0xc78(%rbp),%rax
movsbl -0x1(%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0xc99(%rbp)
mov    -0xc99(%rbp),%al
test   $0x1,%al
jne    148c <xmlq+0x34c>
jmp    14a3 <xmlq+0x363>
mov    -0xc78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xc78(%rbp)
jmp    1443 <xmlq+0x303>
mov    -0xc78(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xca0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<xmlq>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc48,%rsp
xor    %eax,%eax
test   %rdi,%rdi
je     1518 <xmlq+0x3d8>
mov    %rdx,%rbx
test   %rdx,%rdx
je     1518 <xmlq+0x3d8>
mov    %rcx,%rbp
test   %rcx,%rcx
je     1518 <xmlq+0x3d8>
test   %r8d,%r8d
je     1518 <xmlq+0x3d8>
mov    %esi,%r13d
mov    %rdi,%r12
movb   $0x0,0x0(%rbp)
mov    %rbx,%rdi
call   1030 <strlen@plt>
cmp    $0x3ff,%eax
jle    119d <xmlq+0x5d>
xor    %eax,%eax
jmp    1518 <xmlq+0x3d8>
mov    %rbp,(%rsp)
lea    -0x1(%r12),%rbp
cs nopw 0x0(%rax,%rax,1)
movsbl 0x1(%rbp),%edi
add    $0x1,%rbp
call   1050 <isspace@plt>
test   %rax,%rax
jne    11b0 <xmlq+0x70>
cmpb   $0x3c,0x0(%rbp)
jne    128e <xmlq+0x14e>
lea    0xe2d(%rip),%rdx
lea    0x830(%rsp),%r14
mov    %r14,%rdi
mov    $0x40a,%esi
mov    %rbx,%rcx
call   1040 <snprintf@plt>
lea    0xe13(%rip),%rdx
lea    0x420(%rsp),%rdi
mov    $0x40a,%esi
mov    %rbx,%rcx
call   1040 <snprintf@plt>
lea    0xdfc(%rip),%rdx
lea    0x10(%rsp),%rdi
mov    $0x40a,%esi
mov    %rbx,%rcx
call   1040 <snprintf@plt>
add    $0x1,%r13d
mov    $0x1,%r15d
jmp    1250 <xmlq+0x110>
nopl   0x0(%rax)
mov    %rax,%rbx
mov    %r14,%rdi
call   1030 <strlen@plt>
cltq
add    %rax,%rbx
lea    0x1(%rbx),%rbp
lea    0x1(%r15),%eax
cmp    %r13d,%r15d
mov    %eax,%r15d
je     1295 <xmlq+0x155>
mov    %rbp,%rdi
mov    %r14,%rsi
call   1060 <strstr@plt>
test   %rax,%rax
jne    1230 <xmlq+0xf0>
mov    %rbp,%rdi
lea    0x420(%rsp),%rsi
call   1060 <strstr@plt>
test   %rax,%rax
je     128e <xmlq+0x14e>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rax),%rbx
cmpb   $0x3e,(%rax)
mov    %rbx,%rax
jne    1280 <xmlq+0x140>
jmp    1240 <xmlq+0x100>
xor    %ebp,%ebp
jmp    1515 <xmlq+0x3d5>
lea    0x10(%rsp),%rsi
mov    %rbx,%rdi
call   1060 <strstr@plt>
mov    %rax,%r14
test   %rax,%rax
jne    12b8 <xmlq+0x178>
mov    %r12,%rdi
call   1030 <strlen@plt>
movslq %eax,%r14
add    %r12,%r14
mov    %r14,%rax
sub    %rbx,%rax
mov    %rax,0x8(%rsp)
lea    0x1(%rax),%r12
xor    %r13d,%r13d
mov    %rbx,%rbp
nopl   (%rax)
movsbl (%rbx,%r13,1),%edi
call   1050 <isspace@plt>
add    $0x1,%rbp
add    $0x1,%r13
add    $0xffffffffffffffff,%r12
test   %rax,%rax
jne    12d0 <xmlq+0x190>
lea    (%rbx,%r13,1),%rax
add    $0xffffffffffffffff,%rax
mov    (%rsp),%rbp
mov    %rbp,%r15
cmp    %r14,%rax
je     14f0 <xmlq+0x3b0>
mov    0x8(%rsp),%r8
sub    %r13,%r8
add    $0x1,%r8
cmp    $0x20,%r8
jae    131d <xmlq+0x1dd>
mov    %rbp,%r15
jmp    146b <xmlq+0x32b>
lea    0x1(%r14),%rcx
sub    %rbx,%rcx
sub    %r13,%rcx
add    %rax,%rcx
cmp    %rbp,%rcx
jbe    1349 <xmlq+0x209>
lea    (%r14,%rbp,1),%rcx
add    $0x1,%rcx
sub    %rbx,%rcx
sub    %r13,%rcx
mov    %rbp,%r15
cmp    %rcx,%rax
jb     146b <xmlq+0x32b>
mov    %r8,%rbp
and    $0xffffffffffffffe0,%rbp
lea    -0x20(%rbp),%rcx
mov    %rcx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
cmp    $0x60,%rcx
jae    1369 <xmlq+0x229>
xor    %ecx,%ecx
jmp    13e5 <xmlq+0x2a5>
mov    %rdx,%rsi
and    $0xfffffffffffffffc,%rsi
xor    %ecx,%ecx
mov    (%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
lea    (%rbx,%rcx,1),%rdi
movups -0x1(%r13,%rdi,1),%xmm0
movups 0xf(%r13,%rdi,1),%xmm1
movups %xmm0,(%rax,%rcx,1)
movups %xmm1,0x10(%rax,%rcx,1)
movups 0x1f(%r13,%rdi,1),%xmm0
movups 0x2f(%r13,%rdi,1),%xmm1
movups %xmm0,0x20(%rax,%rcx,1)
movups %xmm1,0x30(%rax,%rcx,1)
movups 0x3f(%r13,%rdi,1),%xmm0
movups 0x4f(%r13,%rdi,1),%xmm1
movups %xmm0,0x40(%rax,%rcx,1)
movups %xmm1,0x50(%rax,%rcx,1)
movups 0x5f(%r13,%rdi,1),%xmm0
movups 0x6f(%r13,%rdi,1),%xmm1
movups %xmm0,0x60(%rax,%rcx,1)
movups %xmm1,0x70(%rax,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rsi
jne    1380 <xmlq+0x240>
test   $0x3,%dl
je     1442 <xmlq+0x302>
mov    (%rsp),%rax
lea    (%rcx,%rax,1),%rdx
add    $0x10,%rdx
mov    %r8d,%eax
and    $0x60,%al
add    $0xe0,%al
shr    $0x5,%al
add    $0x1,%al
movzbl %al,%esi
and    $0x3,%esi
shl    $0x5,%rsi
add    %rbx,%rcx
add    $0xf,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rcx,%rdi,1),%rax
movups -0x10(%r13,%rax,1),%xmm0
movups 0x0(%r13,%rax,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1420 <xmlq+0x2e0>
mov    (%rsp),%rax
lea    (%rax,%rbp,1),%r15
cmp    %rbp,%r8
jne    1458 <xmlq+0x318>
mov    (%rsp),%rbp
jmp    14f0 <xmlq+0x3b0>
and    $0xffffffffffffffe0,%r12
add    %r12,%rbx
lea    (%rbx,%r13,1),%rax
add    $0xffffffffffffffff,%rax
mov    (%rsp),%rbp
mov    %r14d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
and    $0x7,%rdx
je     1494 <xmlq+0x354>
nop
movzbl (%rax),%ebx
add    $0x1,%rax
mov    %bl,(%r15)
add    $0x1,%r15
add    $0xffffffffffffffff,%rdx
jne    1480 <xmlq+0x340>
cmp    $0x7,%rcx
jb     14f0 <xmlq+0x3b0>
nopw   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
mov    %cl,(%r15)
movzbl 0x1(%rax),%ecx
mov    %cl,0x1(%r15)
movzbl 0x2(%rax),%ecx
mov    %cl,0x2(%r15)
movzbl 0x3(%rax),%ecx
mov    %cl,0x3(%r15)
movzbl 0x4(%rax),%ecx
mov    %cl,0x4(%r15)
movzbl 0x5(%rax),%ecx
mov    %cl,0x5(%r15)
movzbl 0x6(%rax),%ecx
mov    %cl,0x6(%r15)
movzbl 0x7(%rax),%ecx
mov    %cl,0x7(%r15)
add    $0x8,%r15
add    $0x8,%rax
cmp    %r14,%rax
jne    14a0 <xmlq+0x360>
nopl   0x0(%rax,%rax,1)
cmp    %rbp,%r15
je     150e <xmlq+0x3ce>
movsbl -0x1(%r15),%edi
add    $0xffffffffffffffff,%r15
call   1050 <isspace@plt>
test   %rax,%rax
jne    14f0 <xmlq+0x3b0>
add    $0x1,%r15
jmp    1511 <xmlq+0x3d1>
mov    %rbp,%r15
movb   $0x0,(%r15)
mov    %rbp,%rax
add    $0xc48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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