LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::StrPair::ParseText(char*, char const*, int)
char* StrPair::ParseText( char* p, const char* endTag, int strFlags )
{
    TIXMLASSERT( endTag && *endTag );

    char* start = p;
    char  endChar = *endTag;
    size_t length = strlen( endTag );

    // Inner loop of text parsing.
    while ( *p ) {
        if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
            Set( start, p, strFlags );
            return p + length;
        }
        ++p;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, -0x38(%rbp)
movb (%rdx), %r15b
movq %rdx, %rdi
callq 0x4100
movq %rax, %rbx
movb (%r12), %al
testb %al, %al
je 0xc7c1
movl %r13d, -0x2c(%rbp)
movq %r12, %r13
cmpb %r15b, %al
jne 0xc7b6
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4110
testl %eax, %eax
je 0xc7c5
movb 0x1(%r13), %al
incq %r13
testb %al, %al
jne 0xc79f
xorl %ebx, %ebx
jmp 0xc7f4
movq -0x38(%rbp), %r14
testb $0x2, 0x1(%r14)
je 0xc7de
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xc7de
callq 0x4280
movq %r12, 0x8(%r14)
movq %r13, 0x10(%r14)
movl -0x2c(%rbp), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, (%r14)
addq %r13, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::StrPair::ParseName(char*)
char* StrPair::ParseName( char* p )
{
    if ( !p || !(*p) ) {
        return 0;
    }

    char* const start = p;

    while( *p && ( p == start ? XMLUtil::IsNameStartChar( *p ) : XMLUtil::IsNameChar( *p ) )) {
        ++p;
    }

    if ( p > start ) {
        Set( start, p, 0 );
        return p;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xc8cf
movq %rsi, %r15
movb (%rsi), %r13b
testb %r13b, %r13b
je 0xc8cf
movq %rdi, %r14
xorl %ebx, %ebx
testq %rbx, %rbx
je 0xc873
testb %r13b, %r13b
js 0xc894
movzbl %r13b, %r12d
movl %r12d, %edi
callq 0x4370
testl %eax, %eax
jne 0xc894
cmpb $0x3a, %r13b
je 0xc894
cmpl $0x5f, %r12d
je 0xc894
addl $-0x30, %r12d
cmpl $0xa, %r12d
setae %al
addb $-0x2d, %r13b
cmpb $0x2, %r13b
setae %cl
testb %al, %cl
je 0xc894
jmp 0xc8a1
testb %r13b, %r13b
js 0xc894
movzbl %r13b, %r12d
movl %r12d, %edi
callq 0x4370
testl %eax, %eax
jne 0xc894
cmpb $0x3a, %r13b
je 0xc894
cmpl $0x5f, %r12d
jne 0xc8cf
movb 0x1(%r15,%rbx), %r13b
incq %rbx
testb %r13b, %r13b
jne 0xc831
addq %r15, %rbx
cmpq %r15, %rbx
jbe 0xc8cf
testb $0x2, 0x1(%r14)
je 0xc8be
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xc8be
callq 0x4280
movq %r15, 0x8(%r14)
movq %rbx, 0x10(%r14)
movl $0x100, (%r14)          # imm = 0x100
jmp 0xc8d1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::StrPair::CollapseWhitespace()
void StrPair::CollapseWhitespace()
{
    // Adjusting _start would cause undefined behavior on delete[]
    TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
    // Trim leading space.
    _start = XMLUtil::SkipWhiteSpace( _start );

    if ( _start && *_start ) {
        char* p = _start;	// the read pointer
        char* q = _start;	// the write pointer

        while( *p ) {
            if ( XMLUtil::IsWhiteSpace( *p )) {
                p = XMLUtil::SkipWhiteSpace( p );
                if ( *p == 0 ) {
                    break;    // don't write to q; this trims the trailing space.
                }
                *q = ' ';
                ++q;
            }
            *q = *p;
            ++q;
            ++p;
        }
        *q = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movb (%r14), %al
testb %al, %al
js 0xc911
movzbl %al, %edi
callq 0x4060
testl %eax, %eax
je 0xc911
movb 0x1(%r14), %al
incq %r14
jmp 0xc8f8
movq %r14, 0x8(%rbx)
movb (%r14), %r15b
testb %r15b, %r15b
je 0xc972
movq %r14, %rbx
testb %r15b, %r15b
js 0xc95c
movzbl %r15b, %edi
callq 0x4060
testl %eax, %eax
je 0xc95c
movzbl %r15b, %edi
callq 0x4060
testl %eax, %eax
je 0xc94d
movb 0x1(%rbx), %r15b
incq %rbx
testb %r15b, %r15b
jns 0xc932
jmp 0xc952
testb %r15b, %r15b
je 0xc96e
movb $0x20, (%r14)
incq %r14
movb (%rbx), %r15b
movb %r15b, (%r14)
incq %r14
movb 0x1(%rbx), %r15b
incq %rbx
testb %r15b, %r15b
jne 0xc920
movb $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLUtil::ReadBOM(char const*, bool*)
const char* XMLUtil::ReadBOM( const char* p, bool* bom )
{
    *bom = false;
    const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);
    // Check for BOM:
    if (    *(pu+0) == TIXML_UTF_LEAD_0
            && *(pu+1) == TIXML_UTF_LEAD_1
            && *(pu+2) == TIXML_UTF_LEAD_2 ) {
        *bom = true;
        p += 3;
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movb $0x0, (%rsi)
cmpb $-0x11, (%rdi)
jne 0xcc98
cmpb $-0x45, 0x1(%rax)
jne 0xcc98
cmpb $-0x41, 0x2(%rax)
jne 0xcc98
movb $0x1, (%rsi)
addq $0x3, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLUtil::ConvertUTF32ToUTF8(unsigned long, char*, int*)
void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
{
    const unsigned long BYTE_MASK = 0xBF;
    const unsigned long BYTE_MARK = 0x80;
    const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };

    if (input < 0x80) {
        *length = 1;
    }
    else if ( input < 0x800 ) {
        *length = 2;
    }
    else if ( input < 0x10000 ) {
        *length = 3;
    }
    else if ( input < 0x200000 ) {
        *length = 4;
    }
    else {
        *length = 0;    // This code won't covert this correctly anyway.
        return;
    }

    output += *length;

    // Scary scary fall throughs.
    switch (*length) {
        case 4:
            --output;
            *output = (char)((input | BYTE_MARK) & BYTE_MASK);
            input >>= 6;
        case 3:
            --output;
            *output = (char)((input | BYTE_MARK) & BYTE_MASK);
            input >>= 6;
        case 2:
            --output;
            *output = (char)((input | BYTE_MARK) & BYTE_MASK);
            input >>= 6;
        case 1:
            --output;
            *output = (char)(input | FIRST_BYTE_MARK[*length]);
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0xc0, -0x30(%rbp)
movq $0xe0, -0x28(%rbp)
movq $0xf0, -0x20(%rbp)
movq $0xf8, -0x18(%rbp)
movq $0xfc, -0x10(%rbp)
cmpq $0x80, %rdi
jae 0xcce3
movl $0x1, (%rdx)
movl $0x1, %eax
jmp 0xcd3e
cmpq $0x7ff, %rdi            # imm = 0x7FF
ja 0xccf4
movl $0x2, (%rdx)
jmp 0xcd2e
cmpq $0xffff, %rdi           # imm = 0xFFFF
ja 0xcd05
movl $0x3, (%rdx)
jmp 0xcd21
cmpq $0x200000, %rdi         # imm = 0x200000
jae 0xcd47
movl $0x4, (%rdx)
movl %edi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x3(%rsi)
shrq $0x6, %rdi
movl %edi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsi)
shrq $0x6, %rdi
movl %edi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
shrq $0x6, %rdi
movslq (%rdx), %rax
orl -0x40(%rbp,%rax,8), %edi
movb %dil, (%rsi)
popq %rbp
retq
movl $0x0, (%rdx)
jmp 0xcd45
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLUtil::ToBool(char const*, bool*)
bool XMLUtil::ToBool( const char* str, bool* value )
{
    int ival = 0;
    if ( ToInt( str, &ival )) {
        *value = (ival==0) ? false : true;
        return true;
    }
    if ( StringEqual( str, "true" ) ) {
        *value = true;
        return true;
    }
    else if ( StringEqual( str, "false" ) ) {
        *value = false;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x14(%rbp), %rdx
movl $0x0, (%rdx)
leaq 0x5b38(%rip), %rsi      # 0x12970
xorl %eax, %eax
callq 0x41d0
cmpl $0x1, %eax
jne 0xce50
cmpl $0x0, -0x14(%rbp)
setne %al
jmp 0xcefd
movb $0x1, %al
leaq 0x5b28(%rip), %rdx      # 0x12981
cmpq %rdx, %r14
je 0xcefd
movb (%r14), %cl
testb %cl, %cl
je 0xce9a
xorl %esi, %esi
leaq 0x5b0f(%rip), %rdx      # 0x12981
movl %ecx, %edi
cmpb (%rsi,%rdx), %dil
jne 0xcea1
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
je 0xcea1
movb 0x1(%r14,%rsi), %dil
incq %rsi
testb %dil, %dil
jne 0xce74
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
je 0xcefd
addq %rsi, %rdx
cmpb $0x0, (%rdx)
jne 0xcea9
jmp 0xcefd
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
je 0xcefd
leaq 0x5ad6(%rip), %rdx      # 0x12986
cmpq %rdx, %r14
je 0xcee3
testb %cl, %cl
je 0xcef6
xorl %esi, %esi
leaq 0x5ac4(%rip), %rdx      # 0x12986
cmpb (%rsi,%rdx), %cl
jne 0xcee7
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
je 0xcee7
movb 0x1(%r14,%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0xcec2
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
jne 0xcef3
xorl %eax, %eax
jmp 0xcefd
xorl %eax, %eax
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
je 0xcefd
jmp 0xcf01
addq %rsi, %rdx
xorl %eax, %eax
cmpb $0x0, (%rdx)
jne 0xcf01
movb %al, (%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::Accept(tinyxml2::XMLVisitor*) const
bool XMLDocument::Accept( XMLVisitor* visitor ) const
{
    if ( visitor->VisitEnter( *this ) ) {
        for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
            if ( !node->Accept( visitor ) ) {
                break;
            }
        }
    }
    return visitor->VisitExit( *this );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq 0x30(%rbx), %r15
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xd2e2
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x70(%rax)
testb %al, %al
je 0xd2e2
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0xd2c9
movq (%r14), %rax
movq 0x18(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::DeleteChildren()
void XMLNode::DeleteChildren()
{
    while( _firstChild ) {
        XMLNode* node = _firstChild;
        Unlink( node );

        DeleteNode( node );
    }
    _firstChild = _lastChild = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x30(%rdi), %r12
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0xd37b
movq %rdi, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd38c
movq (%r14), %rax
movq 0x50(%r14), %r15
movq %r14, %rdi
callq *0x80(%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
movq 0x30(%rbx), %r14
testq %r14, %r14
jne 0xd34b
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::Unlink(tinyxml2::XMLNode*)
void XMLNode::Unlink( XMLNode* child )
{
    if ( child == _firstChild ) {
        _firstChild = _firstChild->_next;
    }
    if ( child == _lastChild ) {
        _lastChild = _lastChild->_prev;
    }

    if ( child->_prev ) {
        child->_prev->_next = child->_next;
    }
    if ( child->_next ) {
        child->_next->_prev = child->_prev;
    }
	child->_parent = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rdi), %rax
cmpq %rsi, %rax
jne 0xd3a1
movq 0x48(%rax), %rax
movq %rax, 0x30(%rdi)
movq 0x38(%rdi), %rax
cmpq %rsi, %rax
jne 0xd3b2
movq 0x40(%rax), %rax
movq %rax, 0x38(%rdi)
movq 0x40(%rsi), %rax
movq 0x48(%rsi), %rcx
testq %rax, %rax
je 0xd3c3
movq %rcx, 0x48(%rax)
testq %rcx, %rcx
je 0xd3cc
movq %rax, 0x40(%rcx)
movq $0x0, 0x10(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::SetValue(char const*, bool)
void XMLNode::SetValue( const char* str, bool staticMem )
{
    if ( staticMem ) {
        _value.SetInternedStr( str );
    }
    else {
        _value.SetStr( str );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
testl %edx, %edx
je 0xd42c
testb $0x2, 0x1(%rdi)
je 0xd413
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xd413
callq 0x4280
movl $0x0, 0x18(%r14)
movq $0x0, 0x28(%r14)
movq %rbx, 0x20(%r14)
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xc6e0
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::DeleteNode(tinyxml2::XMLNode*)
void XMLNode::DeleteNode( XMLNode* node )
{
    if ( node == 0 ) {
        return;
    }
    MemPool* pool = node->_memPool;
    node->~XMLNode();
    pool->Free( node );
}

// Assembly:
testq %rdi, %rdi
je 0xd469
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x50(%rdi), %r14
callq *0x80(%rax)
movq (%r14), %rax
movq 0x20(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::InsertEndChild(tinyxml2::XMLNode*)
XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
{
	if (addThis->_document != _document)
		return 0;

	if (addThis->_parent)
		addThis->_parent->Unlink( addThis );
	else
	   addThis->_memPool->SetTracked();

    if ( _lastChild ) {
        TIXMLASSERT( _firstChild );
        TIXMLASSERT( _lastChild->_next == 0 );
        _lastChild->_next = addThis;
        addThis->_prev = _lastChild;
        _lastChild = addThis;

        addThis->_next = 0;
    }
    else {
        TIXMLASSERT( _firstChild == 0 );
        _firstChild = _lastChild = addThis;

        addThis->_prev = 0;
        addThis->_next = 0;
    }
    addThis->_parent = this;
    return addThis;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rax
cmpq 0x8(%rdi), %rax
je 0xd4b3
xorl %ebx, %ebx
jmp 0xd500
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0xd4cc
movq %rbx, %rsi
callq 0xd38c
jmp 0xd4d6
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x38(%r14), %rax
leaq 0x30(%r14), %rcx
leaq 0x48(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %rbx, (%rdx)
movq %rbx, 0x38(%r14)
movq %rax, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::InsertFirstChild(tinyxml2::XMLNode*)
XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
{
	if (addThis->_document != _document)
		return 0;

	if (addThis->_parent)
		addThis->_parent->Unlink( addThis );
	else
	   addThis->_memPool->SetTracked();

    if ( _firstChild ) {
        TIXMLASSERT( _lastChild );
        TIXMLASSERT( _firstChild->_prev == 0 );

        _firstChild->_prev = addThis;
        addThis->_next = _firstChild;
        _firstChild = addThis;

        addThis->_prev = 0;
    }
    else {
        TIXMLASSERT( _lastChild == 0 );
        _firstChild = _lastChild = addThis;

        addThis->_prev = 0;
        addThis->_next = 0;
    }
    addThis->_parent = this;
    return addThis;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rax
cmpq 0x8(%rdi), %rax
je 0xd51d
xorl %ebx, %ebx
jmp 0xd56a
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0xd536
movq %rbx, %rsi
callq 0xd38c
jmp 0xd540
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x30(%r14), %rax
leaq 0x38(%r14), %rcx
leaq 0x40(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %rbx, (%rdx)
movq %rbx, 0x30(%r14)
movq $0x0, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::InsertAfterChild(tinyxml2::XMLNode*, tinyxml2::XMLNode*)
XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
{
	if (addThis->_document != _document)
		return 0;

    TIXMLASSERT( afterThis->_parent == this );

    if ( afterThis->_parent != this ) {
        return 0;
    }

    if ( afterThis->_next == 0 ) {
        // The last node or the only node.
        return InsertEndChild( addThis );
    }
	if (addThis->_parent)
		addThis->_parent->Unlink( addThis );
	else
	   addThis->_memPool->SetTracked();
    addThis->_prev = afterThis;
    addThis->_next = afterThis->_next;
    afterThis->_next->_prev = addThis;
    afterThis->_next = addThis;
    addThis->_parent = this;
    return addThis;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rax
cmpq 0x8(%rdi), %rax
jne 0xd592
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdi, 0x10(%rsi)
je 0xd5a2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
cmpq $0x0, 0x48(%r15)
je 0xd5bf
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xd5d4
movq %rbx, %rsi
callq 0xd38c
jmp 0xd5de
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd49e
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %r15, 0x40(%rbx)
movq 0x48(%r15), %rax
movq %rax, 0x48(%rbx)
movq %rbx, 0x40(%rax)
movq %rbx, 0x48(%r15)
movq %r14, 0x10(%rbx)
jmp 0xd594
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::FirstChildElement(char const*) const
const XMLElement* XMLNode::FirstChildElement( const char* value ) const
{
    for( XMLNode* node=_firstChild; node; node=node->_next ) {
        XMLElement* element = node->ToElement();
        if ( element ) {
            if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) {
                return element;
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0xd67a
movq %rsi, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
testq %rax, %rax
je 0xd671
movq %rax, %r15
testq %rbx, %rbx
je 0xd67d
movq %r15, %rdi
addq $0x18, %rdi
callq 0xc97e
cmpq %rbx, %rax
je 0xd67d
movb (%rax), %dl
movq %rbx, %rcx
testb %dl, %dl
je 0xd662
xorl %ecx, %ecx
cmpb (%rbx,%rcx), %dl
jne 0xd669
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd669
movb 0x1(%rax,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xd63f
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd67d
addq %rbx, %rcx
cmpb $0x0, (%rcx)
jne 0xd671
jmp 0xd67d
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd67d
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0xd60e
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::LastChildElement(char const*) const
const XMLElement* XMLNode::LastChildElement( const char* value ) const
{
    for( XMLNode* node=_lastChild; node; node=node->_prev ) {
        XMLElement* element = node->ToElement();
        if ( element ) {
            if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) {
                return element;
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x38(%rdi), %r14
testq %r14, %r14
je 0xd70e
movq %rsi, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
testq %rax, %rax
je 0xd705
movq %rax, %r15
testq %rbx, %rbx
je 0xd711
movq %r15, %rdi
addq $0x18, %rdi
callq 0xc97e
cmpq %rbx, %rax
je 0xd711
movb (%rax), %dl
movq %rbx, %rcx
testb %dl, %dl
je 0xd6f6
xorl %ecx, %ecx
cmpb (%rbx,%rcx), %dl
jne 0xd6fd
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd6fd
movb 0x1(%rax,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xd6d3
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd711
addq %rbx, %rcx
cmpb $0x0, (%rcx)
jne 0xd705
jmp 0xd711
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd711
movq 0x40(%r14), %r14
testq %r14, %r14
jne 0xd6a2
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::NextSiblingElement(char const*) const
const XMLElement* XMLNode::NextSiblingElement( const char* value ) const
{
    for( XMLNode* node=this->_next; node; node = node->_next ) {
        const XMLElement* element = node->ToElement();
        if ( element
                && (!value || XMLUtil::StringEqual( value, node->Value() ))) {
            return element;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x48(%rdi), %r14
testq %r14, %r14
je 0xd79c
movq %rsi, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
testq %rax, %rax
je 0xd793
movq %rax, %r15
testq %rbx, %rbx
je 0xd79f
leaq 0x18(%r14), %rdi
callq 0xc97e
cmpq %rbx, %rax
je 0xd79f
movb (%rbx), %dl
testb %dl, %dl
je 0xd784
xorl %ecx, %ecx
cmpb (%rax,%rcx), %dl
jne 0xd78b
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd78b
movb 0x1(%rbx,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xd761
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd79f
addq %rcx, %rax
cmpb $0x0, (%rax)
jne 0xd793
jmp 0xd79f
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd79f
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0xd736
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLNode::PreviousSiblingElement(char const*) const
const XMLElement* XMLNode::PreviousSiblingElement( const char* value ) const
{
    for( XMLNode* node=_prev; node; node = node->_prev ) {
        const XMLElement* element = node->ToElement();
        if ( element
                && (!value || XMLUtil::StringEqual( value, node->Value() ))) {
            return element;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %r14
testq %r14, %r14
je 0xd82a
movq %rsi, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
testq %rax, %rax
je 0xd821
movq %rax, %r15
testq %rbx, %rbx
je 0xd82d
leaq 0x18(%r14), %rdi
callq 0xc97e
cmpq %rbx, %rax
je 0xd82d
movb (%rbx), %dl
testb %dl, %dl
je 0xd812
xorl %ecx, %ecx
cmpb (%rax,%rcx), %dl
jne 0xd819
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd819
movb 0x1(%rbx,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xd7ef
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd82d
addq %rcx, %rax
cmpb $0x0, (%rax)
jne 0xd821
jmp 0xd82d
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xd82d
movq 0x40(%r14), %r14
testq %r14, %r14
jne 0xd7c4
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLText::ParseDeep(char*, tinyxml2::StrPair*)
char* XMLText::ParseDeep( char* p, StrPair* )
{
    const char* start = p;
    if ( this->CData() ) {
        p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
        if ( !p ) {
            _document->SetError( XML_ERROR_PARSING_CDATA, start, 0 );
        }
        return p;
    }
    else {
        int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
        if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {
            flags |= StrPair::COLLAPSE_WHITESPACE;
        }

        p = _value.ParseText( p, "<", flags );
        if ( !p ) {
            _document->SetError( XML_ERROR_PARSING_TEXT, start, 0 );
        }
        if ( p && *p ) {
            return p-1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x58(%rdi)
jne 0xdaf1
leaq 0x18(%r14), %rdi
leaq 0x4ed8(%rip), %rdx      # 0x129aa
movq %rbx, %rsi
movl $0x2, %ecx
callq 0xc764
testq %rax, %rax
jne 0xdb43
movq 0x8(%r14), %rax
movl $0xb, 0x5c(%rax)
jmp 0xdb35
movq 0x8(%r14), %rax
xorl %ecx, %ecx
cmpl $0x1, 0x60(%rax)
movzbl 0x59(%rax), %eax
sete %cl
leal (%rax,%rcx,4), %ecx
addl $0x2, %ecx
leaq 0x18(%r14), %rdi
leaq 0x4e95(%rip), %rdx      # 0x129a8
movq %rbx, %rsi
callq 0xc764
testq %rax, %rax
je 0xdb2a
cmpb $0x0, (%rax)
je 0xdb41
decq %rax
jmp 0xdb43
movq 0x8(%r14), %rax
movl $0xa, 0x5c(%rax)
movq %rbx, 0x68(%rax)
movq $0x0, 0x70(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLText::ShallowClone(tinyxml2::XMLDocument*) const
XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
{
    if ( !doc ) {
        doc = _document;
    }
    XMLText* text = doc->NewText( Value() );	// fixme: this will always allocate memory. Intern?
    text->SetCData( this->CData() );
    return text;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0xdb5e
movq 0x8(%rbx), %r14
leaq 0x18(%rbx), %rdi
callq 0xc97e
movq %r14, %rdi
movq %rax, %rsi
callq 0xdb7e
movb 0x58(%rbx), %cl
movb %cl, 0x58(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::NewText(char const*)
XMLText* XMLDocument::NewText( const char* str )
{
    XMLText* text = new (_textPool.Alloc()) XMLText( this );
    text->_memPool = &_textPool;
    text->SetValue( str );
    return text;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x180(%rdi), %r15
movq %r15, %rdi
callq 0x10752
movq %rax, %r12
movq %r14, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rdi
movl $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
leaq 0xbeaa(%rip), %rax      # 0x19a78
movq %rax, (%r12)
movb $0x0, 0x58(%r12)
movq %r15, 0x50(%r12)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc6e0
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLComment::ParseDeep(char*, tinyxml2::StrPair*)
char* XMLComment::ParseDeep( char* p, StrPair* )
{
    // Comment parses as text.
    const char* start = p;
    p = _value.ParseText( p, "-->", StrPair::COMMENT );
    if ( p == 0 ) {
        _document->SetError( XML_ERROR_PARSING_COMMENT, start, 0 );
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
leaq 0x4f2e(%rip), %rdx      # 0x12c26
movl $0x2, %ecx
callq 0xc764
testq %rax, %rax
jne 0xdd1e
movq 0x8(%r14), %rcx
movl $0xc, 0x5c(%rcx)
movq %rbx, 0x68(%rcx)
movq $0x0, 0x70(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLComment::ShallowClone(tinyxml2::XMLDocument*) const
XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
{
    if ( !doc ) {
        doc = _document;
    }
    XMLComment* comment = doc->NewComment( Value() );	// fixme: this will always allocate memory. Intern?
    return comment;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
jne 0xdd3b
movq 0x8(%rdi), %rbx
addq $0x18, %rdi
callq 0xc97e
movq %rax, %r14
leaq 0x200(%rbx), %r15
movq %r15, %rdi
callq 0x106b4
movq %rax, %r12
movq %rbx, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rdi
movl $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
leaq 0xb95a(%rip), %rax      # 0x196e0
movq %rax, (%r12)
movq %r15, 0x50(%r12)
movq %r14, %rsi
xorl %edx, %edx
callq 0xc6e0
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::NewComment(char const*)
XMLComment* XMLDocument::NewComment( const char* str )
{
    XMLComment* comment = new (_commentPool.Alloc()) XMLComment( this );
    comment->_memPool = &_commentPool;
    comment->SetValue( str );
    return comment;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x200(%rdi), %r15
movq %r15, %rdi
callq 0x106b4
movq %rax, %r12
movq %r14, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rdi
movl $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
leaq 0xb8ea(%rip), %rax      # 0x196e0
movq %rax, (%r12)
movq %r15, 0x50(%r12)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc6e0
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDeclaration::ParseDeep(char*, tinyxml2::StrPair*)
char* XMLDeclaration::ParseDeep( char* p, StrPair* )
{
    // Declaration parses as text.
    const char* start = p;
    p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
    if ( p == 0 ) {
        _document->SetError( XML_ERROR_PARSING_DECLARATION, start, 0 );
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
leaq 0x4d14(%rip), %rdx      # 0x12c2e
movl $0x2, %ecx
callq 0xc764
testq %rax, %rax
jne 0xdf40
movq 0x8(%r14), %rcx
movl $0xd, 0x5c(%rcx)
movq %rbx, 0x68(%rcx)
movq $0x0, 0x70(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::NewDeclaration(char const*)
XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
{
    XMLDeclaration* dec = new (_commentPool.Alloc()) XMLDeclaration( this );
    dec->_memPool = &_commentPool;
    dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
    return dec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x200(%rdi), %r15
movq %r15, %rdi
callq 0x106b4
movq %rax, %r12
movq %r14, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rdi
movl $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
leaq 0xb7be(%rip), %rax      # 0x19780
movq %rax, (%r12)
movq %r15, 0x50(%r12)
testq %rbx, %rbx
leaq 0x4bc3(%rip), %rsi      # 0x12b98
cmovneq %rbx, %rsi
xorl %edx, %edx
callq 0xc6e0
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLUnknown::ParseDeep(char*, tinyxml2::StrPair*)
char* XMLUnknown::ParseDeep( char* p, StrPair* )
{
    // Unknown parses as text.
    const char* start = p;

    p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION );
    if ( !p ) {
        _document->SetError( XML_ERROR_PARSING_UNKNOWN, start, 0 );
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
leaq 0x4b38(%rip), %rdx      # 0x12c28
movl $0x2, %ecx
callq 0xc764
testq %rax, %rax
jne 0xe116
movq 0x8(%r14), %rcx
movl $0xe, 0x5c(%rcx)
movq %rbx, 0x68(%rcx)
movq $0x0, 0x70(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLUnknown::ShallowClone(tinyxml2::XMLDocument*) const
XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
{
    if ( !doc ) {
        doc = _document;
    }
    XMLUnknown* text = doc->NewUnknown( Value() );	// fixme: this will always allocate memory. Intern?
    return text;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
jne 0xe133
movq 0x8(%rdi), %rbx
addq $0x18, %rdi
callq 0xc97e
movq %rax, %r14
leaq 0x200(%rbx), %r15
movq %r15, %rdi
callq 0x106b4
movq %rax, %r12
movq %rbx, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rdi
movl $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
leaq 0xb6a2(%rip), %rax      # 0x19820
movq %rax, (%r12)
movq %r15, 0x50(%r12)
movq %r14, %rsi
xorl %edx, %edx
callq 0xc6e0
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLAttribute::ParseDeep(char*, bool)
char* XMLAttribute::ParseDeep( char* p, bool processEntities )
{
    // Parse using the name rules: bug fix, was using ParseText before
    p = _name.ParseName( p );
    if ( !p || !*p ) {
        return 0;
    }

    // Skip white space before =
    p = XMLUtil::SkipWhiteSpace( p );
    if ( !p || *p != '=' ) {
        return 0;
    }

    ++p;	// move up to opening quote
    p = XMLUtil::SkipWhiteSpace( p );
    if ( *p != '\"' && *p != '\'' ) {
        return 0;
    }

    char endTag[2] = { *p, 0 };
    ++p;	// move past opening quote

    p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES );
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
addq $0x8, %rdi
callq 0xc806
testq %rax, %rax
je 0xe373
movq %rax, %r15
movb (%rax), %r13b
testb %r13b, %r13b
jle 0xe373
incq %r15
xorl %r12d, %r12d
movzbl %r13b, %edi
callq 0x4060
testl %eax, %eax
je 0xe317
movb (%r15), %r13b
incq %r15
testb %r13b, %r13b
jns 0xe2fd
jmp 0xe376
cmpb $0x3d, %r13b
jne 0xe373
movb (%r15), %r12b
testb %r12b, %r12b
js 0xe33b
movzbl %r12b, %edi
callq 0x4060
testl %eax, %eax
je 0xe33b
movb 0x1(%r15), %r12b
incq %r15
jmp 0xe320
cmpb $0x27, %r12b
je 0xe34a
movzbl %r12b, %eax
cmpl $0x22, %eax
jne 0xe373
leaq -0x2a(%rbp), %rdx
movb %r12b, (%rdx)
movb $0x0, 0x1(%rdx)
incq %r15
addq $0x20, %rbx
movzbl %r14b, %ecx
orl $0x2, %ecx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc764
movq %rax, %r12
jmp 0xe376
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::~XMLElement()
XMLElement::~XMLElement()
{
    while( _rootAttribute ) {
        XMLAttribute* next = _rootAttribute->_next;
        DeleteAttribute( _rootAttribute );
        _rootAttribute = next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xb231(%rip), %rax      # 0x198c0
movq %rax, (%rdi)
movq 0x60(%rdi), %r12
testq %r12, %r12
je 0xe6c2
movq %r12, %r14
movq (%r12), %rax
movq 0x38(%r12), %r12
movq 0x40(%r14), %r15
movq %r14, %rdi
callq *(%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
movq %r12, 0x60(%rbx)
jmp 0xe696
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1065a
movq %rax, %rdi
callq 0x7abf
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::DeleteAttribute(tinyxml2::XMLAttribute*)
void XMLElement::DeleteAttribute( XMLAttribute* attribute )
{
    if ( attribute == 0 ) {
        return;
    }
    MemPool* pool = attribute->_memPool;
    attribute->~XMLAttribute();
    pool->Free( attribute );
}

// Assembly:
testq %rdi, %rdi
je 0xe705
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x40(%rdi), %r14
callq *(%rax)
movq (%r14), %rax
movq 0x20(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::FindAttribute(char const*)
XMLAttribute* XMLElement::FindAttribute( const char* name )
{
    for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
        if ( XMLUtil::StringEqual( a->Name(), name ) ) {
            return a;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x60(%rdi), %rbx
testq %rbx, %rbx
je 0xe78a
movq %rsi, %r14
leaq 0x8(%rbx), %rdi
callq 0xc97e
cmpq %r14, %rax
je 0xe78c
movb (%rax), %dl
movq %r14, %rcx
testb %dl, %dl
je 0xe772
xorl %ecx, %ecx
cmpb (%r14,%rcx), %dl
jne 0xe779
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xe779
movb 0x1(%rax,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xe74e
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xe78c
addq %r14, %rcx
cmpb $0x0, (%rcx)
jne 0xe781
jmp 0xe78c
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xe78c
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0xe735
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::Attribute(char const*, char const*) const
const char* XMLElement::Attribute( const char* name, const char* value ) const
{
    const XMLAttribute* a = FindAttribute( name );
    if ( !a ) {
        return 0;
    }
    if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
        return a->Value();
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
callq 0xe794
testq %rax, %rax
je 0xe862
movq %rax, %rbx
testq %r14, %r14
je 0xe871
leaq 0x20(%rbx), %rdi
callq 0xc97e
cmpq %r14, %rax
je 0xe871
movb (%rax), %dl
testb %dl, %dl
je 0xe85c
xorl %ecx, %ecx
cmpb (%r14,%rcx), %dl
jne 0xe869
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xe869
movb 0x1(%rax,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xe838
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xe871
addq %rcx, %r14
cmpb $0x0, (%r14)
je 0xe871
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
jne 0xe862
addq $0x20, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc97e
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::SetText(char const*)
void	XMLElement::SetText( const char* inText )
{
	if ( FirstChild() && FirstChild()->ToText() )
		FirstChild()->SetValue( inText );
	else {
		XMLText*	theText = GetDocument()->NewText( inText );
		InsertFirstChild( theText );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xe8f3
movq (%rdi), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0xe8f3
movq 0x30(%r14), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xc6e0
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xdb7e
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xd508
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::QueryIntText(int*) const
XMLError XMLElement::QueryIntText( int* ival ) const
{
    if ( FirstChild() && FirstChild()->ToText() ) {
        const char* t = FirstChild()->Value();
        if ( XMLUtil::ToInt( t, ival ) ) {
            return XML_SUCCESS;
        }
        return XML_CAN_NOT_CONVERT_TEXT;
    }
    return XML_NO_TEXT_NODE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x30(%rdi), %rdi
movl $0x13, %r14d
testq %rdi, %rdi
je 0xead1
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xead1
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xc97e
leaq 0x3ebc(%rip), %rsi      # 0x12970
xorl %r15d, %r15d
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41d0
cmpl $0x1, %eax
movl $0x12, %r14d
cmovel %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::QueryUnsignedText(unsigned int*) const
XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
{
    if ( FirstChild() && FirstChild()->ToText() ) {
        const char* t = FirstChild()->Value();
        if ( XMLUtil::ToUnsigned( t, uval ) ) {
            return XML_SUCCESS;
        }
        return XML_CAN_NOT_CONVERT_TEXT;
    }
    return XML_NO_TEXT_NODE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x30(%rdi), %rdi
movl $0x13, %r14d
testq %rdi, %rdi
je 0xeb3b
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xeb3b
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xc97e
leaq 0x3e55(%rip), %rsi      # 0x12973
xorl %r15d, %r15d
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41d0
cmpl $0x1, %eax
movl $0x12, %r14d
cmovel %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::QueryBoolText(bool*) const
XMLError XMLElement::QueryBoolText( bool* bval ) const
{
    if ( FirstChild() && FirstChild()->ToText() ) {
        const char* t = FirstChild()->Value();
        if ( XMLUtil::ToBool( t, bval ) ) {
            return XML_SUCCESS;
        }
        return XML_CAN_NOT_CONVERT_TEXT;
    }
    return XML_NO_TEXT_NODE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x30(%rdi), %rdi
movl $0x13, %r14d
testq %rdi, %rdi
je 0xeb9a
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xeb9a
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xc97e
movq %rax, %rdi
movq %rbx, %rsi
callq 0xce16
xorl %ecx, %ecx
testb %al, %al
movl $0x12, %r14d
cmovnel %ecx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::QueryDoubleText(double*) const
XMLError XMLElement::QueryDoubleText( double* dval ) const
{
    if ( FirstChild() && FirstChild()->ToText() ) {
        const char* t = FirstChild()->Value();
        if ( XMLUtil::ToDouble( t, dval ) ) {
            return XML_SUCCESS;
        }
        return XML_CAN_NOT_CONVERT_TEXT;
    }
    return XML_NO_TEXT_NODE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x30(%rdi), %rdi
movl $0x13, %r14d
testq %rdi, %rdi
je 0xec03
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xec03
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xc97e
leaq 0x3da9(%rip), %rsi      # 0x1298f
xorl %r15d, %r15d
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41d0
cmpl $0x1, %eax
movl $0x12, %r14d
cmovel %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::QueryFloatText(float*) const
XMLError XMLElement::QueryFloatText( float* fval ) const
{
    if ( FirstChild() && FirstChild()->ToText() ) {
        const char* t = FirstChild()->Value();
        if ( XMLUtil::ToFloat( t, fval ) ) {
            return XML_SUCCESS;
        }
        return XML_CAN_NOT_CONVERT_TEXT;
    }
    return XML_NO_TEXT_NODE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x30(%rdi), %rdi
movl $0x13, %r14d
testq %rdi, %rdi
je 0xec6d
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xec6d
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xc97e
leaq 0x3d3c(%rip), %rsi      # 0x1298c
xorl %r15d, %r15d
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41d0
cmpl $0x1, %eax
movl $0x12, %r14d
cmovel %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::FindOrCreateAttribute(char const*)
XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
{
    XMLAttribute* last = 0;
    XMLAttribute* attrib = 0;
    for( attrib = _rootAttribute;
            attrib;
            last = attrib, attrib = attrib->_next ) {
        if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {
            break;
        }
    }
    if ( !attrib ) {
        attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
        attrib->_memPool = &_document->_attributePool;
        if ( last ) {
            last->_next = attrib;
        }
        else {
            _rootAttribute = attrib;
        }
        attrib->SetName( name );
        attrib->_memPool->SetTracked(); // always created and linked.
    }
    return attrib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0xed01
movq %rax, %r14
leaq 0x8(%rax), %rdi
callq 0xc97e
cmpq %rbx, %rax
je 0xed82
movb (%rax), %dl
movq %rbx, %rcx
testb %dl, %dl
je 0xece0
xorl %ecx, %ecx
cmpb (%rbx,%rcx), %dl
jne 0xecea
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xecea
movb 0x1(%rax,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xecb9
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xed82
addq %rbx, %rcx
cmpb $0x0, (%rcx)
jne 0xecf6
jmp 0xed82
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xed82
movq 0x38(%r14), %rax
testq %rax, %rax
jne 0xec99
jmp 0xed04
xorl %r14d, %r14d
leaq 0x60(%r15), %rax
movq %rax, -0x30(%rbp)
movl $0x100, %r13d           # imm = 0x100
movq 0x8(%r15), %rdi
addq %r13, %rdi
callq 0x1088e
xorl %ecx, %ecx
movq %rax, %r12
leaq 0xaeb6(%rip), %rax      # 0x19be0
movq %rax, (%r12)
leaq 0x8(%r12), %rdi
movl %ecx, 0x8(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movl %ecx, 0x20(%r12)
movups %xmm0, 0x28(%r12)
movups %xmm0, 0x38(%r12)
addq 0x8(%r15), %r13
movq %r13, 0x40(%r12)
leaq 0x38(%r14), %rax
testq %r14, %r14
cmoveq -0x30(%rbp), %rax
movq %r12, (%rax)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc6e0
movq 0x40(%r12), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %r12, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq