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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
char *strstr(char *, char *);
scalar_t__ xml_malloc(int);
void parse_tag(char *tag, char **prefix, char **name, char **uri) {
  char *ns_tag, *prefix_char;
  int have_prefix = 0;
  int have_uri = 0;
  prefix_char = strstr(tag, ":");
  if ((ns_tag = strstr(tag, "xmlns")) != NULL) {
    have_uri = 1;
    if ((prefix_char != NULL) && (prefix_char < ns_tag))
      have_prefix = 1;
  } else if (prefix_char) {
    have_prefix = 1;
  }
  if (have_prefix && have_uri) {
    char *prefix_front, *prefix_rear, *name_front, *name_rear, *uri_front,
        *uri_rear;
    int prefix_len, name_len, uri_len;
    prefix_front = tag;
    prefix_rear = prefix_char;
    prefix_len = prefix_rear - prefix_front;
    *prefix = (char *)xml_malloc(prefix_len + 1);
    memcpy(*prefix, prefix_front, prefix_len);
    (*prefix)[prefix_len] = '\0';
    name_front = prefix_char + 1;
    name_rear = ns_tag - 1;
    name_len = name_rear - name_front;
    *name = (char *)xml_malloc(name_len + 1);
    memcpy(*name, name_front, name_len);
    (*name)[name_len] = '\0';
    uri_front = strstr(ns_tag, "\"") + 1;
    uri_rear = strstr(uri_front, "\"");
    uri_len = uri_rear - uri_front;
    *uri = (char *)xml_malloc(uri_len + 1);
    memcpy(*uri, uri_front, uri_len);
    (*uri)[uri_len] = '\0';
  } else if (have_prefix) {
    char *prefix_front, *prefix_rear, *name_front, *name_rear;
    int prefix_len, name_len;
    prefix_front = tag;
    prefix_rear = prefix_char;
    prefix_len = prefix_rear - prefix_front;
    *prefix = (char *)xml_malloc(prefix_len + 1);
    memcpy(*prefix, prefix_front, prefix_len);
    (*prefix)[prefix_len] = '\0';
    name_front = prefix_char + 1;
    name_rear = tag + strlen(tag);
    name_len = name_rear - name_front;
    *name = (char *)xml_malloc(name_len + 1);
    memcpy(*name, name_front, name_len);
    (*name)[name_len] = '\0';
    *uri = NULL;
  } else if (have_uri) {
    char *name_front, *name_rear, *uri_front, *uri_rear;
    int name_len, uri_len;
    *prefix = NULL;
    name_front = tag;
    name_rear = ns_tag - 1;
    name_len = name_rear - name_front;
    *name = (char *)xml_malloc(name_len + 1);
    memcpy(*name, name_front, name_len);
    (*name)[name_len] = '\0';
    uri_front = strstr(ns_tag, "\"") + 1;
    uri_rear = strstr(uri_front, "\"");
    uri_len = uri_rear - uri_front;
    *uri = (char *)xml_malloc(uri_len + 1);
    memcpy(*uri, uri_front, uri_len);
    (*uri)[uri_len] = '\0';
  } else {
    *prefix = NULL;
    *name = (char *)xml_malloc(strlen(tag) + 1);
    strcpy(*name, tag);
    *uri = NULL;
  }
}


x86 assembly (clang, -O0):
<parse_tag>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe7c(%rip),%rsi
call   1070 <strstr@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe6a(%rip),%rsi
call   1070 <strstr@plt>
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
je     11d7 <parse_tag+0x87>
movl   $0x1,-0x38(%rbp)
cmpq   $0x0,-0x30(%rbp)
je     11d2 <parse_tag+0x82>
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    11d2 <parse_tag+0x82>
movl   $0x1,-0x34(%rbp)
jmp    11ee <parse_tag+0x9e>
cmpq   $0x0,-0x30(%rbp)
je     11e9 <parse_tag+0x99>
movl   $0x1,-0x34(%rbp)
jmp    11ee <parse_tag+0x9e>
cmpl   $0x0,-0x34(%rbp)
je     132a <parse_tag+0x1da>
cmpl   $0x0,-0x38(%rbp)
je     132a <parse_tag+0x1da>
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%edi
add    $0x1,%edi
call   1040 <xml_malloc@plt>
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x6c(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x6c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%edi
add    $0x1,%edi
call   1040 <xml_malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x70(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x70(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%rdi
lea    0xd49(%rip),%rsi
call   1070 <strstr@plt>
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
lea    0xd31(%rip),%rsi
call   1070 <strstr@plt>
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x60(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%edi
add    $0x1,%edi
call   1040 <xml_malloc@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x74(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x74(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    15a8 <parse_tag+0x458>
cmpl   $0x0,-0x34(%rbp)
je     143e <parse_tag+0x2ee>
mov    -0x8(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x80(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%edi
add    $0x1,%edi
call   1040 <xml_malloc@plt>
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x9c(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x9c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x8(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0xd0(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%edi
add    $0x1,%edi
call   1040 <xml_malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x90(%rbp),%rsi
mov    -0xa0(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0xa0(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
movq   $0x0,(%rax)
jmp    15a3 <parse_tag+0x453>
cmpl   $0x0,-0x38(%rbp)
je     155b <parse_tag+0x40b>
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%edi
add    $0x1,%edi
call   1040 <xml_malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0xc4(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0xc4(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%rdi
lea    0xb36(%rip),%rsi
call   1070 <strstr@plt>
add    $0x1,%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rdi
lea    0xb18(%rip),%rsi
call   1070 <strstr@plt>
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    -0xb8(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%edi
add    $0x1,%edi
call   1040 <xml_malloc@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0xb8(%rbp),%rsi
mov    -0xc8(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0xc8(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    159e <parse_tag+0x44e>
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x8(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%edi
add    $0x1,%edi
call   1040 <xml_malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x8(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x20(%rbp),%rax
movq   $0x0,(%rax)
jmp    15a3 <parse_tag+0x453>
jmp    15a8 <parse_tag+0x458>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_tag>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r12
mov    %rdx,%rbp
mov    %rsi,%rbx
mov    %rdi,%r15
mov    $0x3a,%esi
call   1060 <strchr@plt>
mov    %rax,%r14
lea    0xe75(%rip),%rsi
mov    %r15,%rdi
call   1080 <strstr@plt>
test   %rax,%rax
je     1259 <parse_tag+0xf9>
mov    %rax,%r13
test   %r14,%r14
je     12cb <parse_tag+0x16b>
cmp    %r13,%r14
jae    12cb <parse_tag+0x16b>
mov    %r12,(%rsp)
mov    %r14,%r12
sub    %r15,%r12
lea    0x1(%r12),%edi
call   1040 <xml_malloc@plt>
mov    %rax,(%rbx)
mov    %rax,%rdi
mov    %r15,%rsi
mov    %r12d,%edx
call   1070 <memcpy@plt>
mov    (%rbx),%rax
movslq %r12d,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x1,%r14
mov    %r14,%rbx
not    %rbx
add    %r13,%rbx
lea    0x1(%rbx),%edi
call   1040 <xml_malloc@plt>
mov    %rax,0x0(%rbp)
mov    %rax,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
call   1070 <memcpy@plt>
mov    0x0(%rbp),%rax
movslq %ebx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    %r13,%rdi
mov    $0x22,%esi
call   1060 <strchr@plt>
lea    0x1(%rax),%r14
mov    %r14,%rdi
mov    $0x22,%esi
call   1060 <strchr@plt>
mov    %rax,%rbp
sub    %r14,%rbp
lea    0x1(%rbp),%edi
call   1040 <xml_malloc@plt>
mov    (%rsp),%rbx
mov    %rax,(%rbx)
mov    %rax,%rdi
mov    %r14,%rsi
mov    %ebp,%edx
call   1070 <memcpy@plt>
mov    (%rbx),%rax
jmp    1340 <parse_tag+0x1e0>
test   %r14,%r14
je     1349 <parse_tag+0x1e9>
mov    %rbp,%r13
mov    %r14,%rbp
sub    %r15,%rbp
lea    0x1(%rbp),%edi
call   1040 <xml_malloc@plt>
mov    %rax,(%rbx)
mov    %rax,%rdi
mov    %r15,%rsi
mov    %ebp,%edx
call   1070 <memcpy@plt>
mov    (%rbx),%rax
movslq %ebp,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x1,%r14
mov    %r15,%rdi
call   1050 <strlen@plt>
movslq %eax,%rbp
add    %r15,%rbp
sub    %r14,%rbp
lea    0x1(%rbp),%edi
call   1040 <xml_malloc@plt>
mov    %rax,0x0(%r13)
mov    %rax,%rdi
mov    %r14,%rsi
mov    %ebp,%edx
call   1070 <memcpy@plt>
mov    0x0(%r13),%rax
movslq %ebp,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    136f <parse_tag+0x20f>
movq   $0x0,(%rbx)
mov    %r15,%rbx
not    %rbx
add    %r13,%rbx
lea    0x1(%rbx),%edi
call   1040 <xml_malloc@plt>
mov    %rax,0x0(%rbp)
mov    %rax,%rdi
mov    %r15,%rsi
mov    %ebx,%edx
call   1070 <memcpy@plt>
mov    0x0(%rbp),%rax
movslq %ebx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    %r13,%rdi
mov    $0x22,%esi
call   1060 <strchr@plt>
lea    0x1(%rax),%rbx
mov    %rbx,%rdi
mov    $0x22,%esi
call   1060 <strchr@plt>
mov    %rax,%rbp
sub    %rbx,%rbp
lea    0x1(%rbp),%edi
call   1040 <xml_malloc@plt>
mov    %rax,(%r12)
mov    %rax,%rdi
mov    %rbx,%rsi
mov    %ebp,%edx
call   1070 <memcpy@plt>
mov    (%r12),%rax
movslq %ebp,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1377 <parse_tag+0x217>
movq   $0x0,(%rbx)
mov    %r15,%rdi
call   1050 <strlen@plt>
lea    0x1(%rax),%edi
call   1040 <xml_malloc@plt>
mov    %rax,0x0(%rbp)
mov    %rax,%rdi
mov    %r15,%rsi
call   1030 <strcpy@plt>
movq   $0x0,(%r12)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str.1 = [6 x i8] c"xmlns\00"
define void @parse_tag(i8* %0, i8** nocapture %1, i8** nocapture %2, i8** nocapture %3) {
%5 = tail call i8* @strchr(i8* dereferenceable(1) %0, i32 58)
%6 = tail call i8* @strstr(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
%7 = icmp eq i8* %6, null
br i1 %7, label %8, label %10
8: ; preds = %4
%9 = icmp eq i8* %5, null
br i1 %9, label %114, label %56
10: ; preds = %4
%11 = icmp ne i8* %5, null
%12 = icmp ult i8* %5, %6
%13 = select i1 %11, i1 %12, i1 false
br i1 %13, label %14, label %85
14: ; preds = %10
%15 = ptrtoint i8* %5 to i64
%16 = ptrtoint i8* %0 to i64
%17 = sub i64 %15, %16
%18 = trunc i64 %17 to i32
%19 = add nsw i32 %18, 1
%20 = tail call i64 @xml_malloc(i32 %19)
%21 = inttoptr i64 %20 to i8*
store i8* %21, i8** %1
%22 = tail call i32 @memcpy(i8* %21, i8* %0, i32 %18)
%23 = load i8*, i8** %1
%24 = shl i64 %17, 32
%25 = ashr exact i64 %24, 32
%26 = getelementptr inbounds i8, i8* %23, i64 %25
store i8 0, i8* %26
%27 = getelementptr inbounds i8, i8* %5, i64 1
%28 = getelementptr inbounds i8, i8* %6, i64 -1
%29 = ptrtoint i8* %28 to i64
%30 = ptrtoint i8* %27 to i64
%31 = sub i64 %29, %30
%32 = trunc i64 %31 to i32
%33 = add nsw i32 %32, 1
%34 = tail call i64 @xml_malloc(i32 %33)
%35 = inttoptr i64 %34 to i8*
store i8* %35, i8** %2
%36 = tail call i32 @memcpy(i8* %35, i8* %27, i32 %32)
%37 = load i8*, i8** %2
%38 = shl i64 %31, 32
%39 = ashr exact i64 %38, 32
%40 = getelementptr inbounds i8, i8* %37, i64 %39
store i8 0, i8* %40
%41 = tail call i8* @strchr(i8* dereferenceable(1) %6, i32 34)
%42 = getelementptr inbounds i8, i8* %41, i64 1
%43 = tail call i8* @strchr(i8* %42, i32 34)
%44 = ptrtoint i8* %43 to i64
%45 = ptrtoint i8* %42 to i64
%46 = sub i64 %44, %45
%47 = trunc i64 %46 to i32
%48 = add nsw i32 %47, 1
%49 = tail call i64 @xml_malloc(i32 %48)
%50 = inttoptr i64 %49 to i8*
store i8* %50, i8** %3
%51 = tail call i32 @memcpy(i8* %50, i8* %42, i32 %47)
%52 = load i8*, i8** %3
%53 = shl i64 %46, 32
%54 = ashr exact i64 %53, 32
%55 = getelementptr inbounds i8, i8* %52, i64 %54
store i8 0, i8* %55
br label %120
56: ; preds = %8
%57 = ptrtoint i8* %5 to i64
%58 = ptrtoint i8* %0 to i64
%59 = sub i64 %57, %58
%60 = trunc i64 %59 to i32
%61 = add nsw i32 %60, 1
%62 = tail call i64 @xml_malloc(i32 %61)
%63 = inttoptr i64 %62 to i8*
store i8* %63, i8** %1
%64 = tail call i32 @memcpy(i8* %63, i8* %0, i32 %60)
%65 = load i8*, i8** %1
%66 = shl i64 %59, 32
%67 = ashr exact i64 %66, 32
%68 = getelementptr inbounds i8, i8* %65, i64 %67
store i8 0, i8* %68
%69 = getelementptr inbounds i8, i8* %5, i64 1
%70 = tail call i32 @strlen(i8* %0)
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %0, i64 %71
%73 = ptrtoint i8* %72 to i64
%74 = ptrtoint i8* %69 to i64
%75 = sub i64 %73, %74
%76 = trunc i64 %75 to i32
%77 = add nsw i32 %76, 1
%78 = tail call i64 @xml_malloc(i32 %77)
%79 = inttoptr i64 %78 to i8*
store i8* %79, i8** %2
%80 = tail call i32 @memcpy(i8* %79, i8* %69, i32 %76)
%81 = load i8*, i8** %2
%82 = shl i64 %75, 32
%83 = ashr exact i64 %82, 32
%84 = getelementptr inbounds i8, i8* %81, i64 %83
store i8 0, i8* %84
store i8* null, i8** %3
br label %120
85: ; preds = %10
store i8* null, i8** %1
%86 = getelementptr inbounds i8, i8* %6, i64 -1
%87 = ptrtoint i8* %86 to i64
%88 = ptrtoint i8* %0 to i64
%89 = sub i64 %87, %88
%90 = trunc i64 %89 to i32
%91 = add nsw i32 %90, 1
%92 = tail call i64 @xml_malloc(i32 %91)
%93 = inttoptr i64 %92 to i8*
store i8* %93, i8** %2
%94 = tail call i32 @memcpy(i8* %93, i8* %0, i32 %90)
%95 = load i8*, i8** %2
%96 = shl i64 %89, 32
%97 = ashr exact i64 %96, 32
%98 = getelementptr inbounds i8, i8* %95, i64 %97
store i8 0, i8* %98
%99 = tail call i8* @strchr(i8* dereferenceable(1) %6, i32 34)
%100 = getelementptr inbounds i8, i8* %99, i64 1
%101 = tail call i8* @strchr(i8* %100, i32 34)
%102 = ptrtoint i8* %101 to i64
%103 = ptrtoint i8* %100 to i64
%104 = sub i64 %102, %103
%105 = trunc i64 %104 to i32
%106 = add nsw i32 %105, 1
%107 = tail call i64 @xml_malloc(i32 %106)
%108 = inttoptr i64 %107 to i8*
store i8* %108, i8** %3
%109 = tail call i32 @memcpy(i8* %108, i8* %100, i32 %105)
%110 = load i8*, i8** %3
%111 = shl i64 %104, 32
%112 = ashr exact i64 %111, 32
%113 = getelementptr inbounds i8, i8* %110, i64 %112
store i8 0, i8* %113
br label %120
114: ; preds = %8
store i8* null, i8** %1
%115 = tail call i32 @strlen(i8* %0)
%116 = add nsw i32 %115, 1
%117 = tail call i64 @xml_malloc(i32 %116)
%118 = inttoptr i64 %117 to i8*
store i8* %118, i8** %2
%119 = tail call i32 @strcpy(i8* %118, i8* %0)
store i8* null, i8** %3
br label %120
120: ; preds = %56, %114, %85, %14
ret void
}