LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
testq %rsi, %rsi
je 0xb03a
movq %rsi, %r15
movb (%rsi), %al
testb %al, %al
je 0xb03a
movq %rdi, %r14
xorl %ebx, %ebx
testb %al, %al
je 0xb019
movzbl %al, %edi
testq %rbx, %rbx
je 0xb006
callq 0xe32a
testb %al, %al
jne 0xb00f
jmp 0xb019
callq 0xe2f6
testb %al, %al
je 0xb03a
movb 0x1(%r15,%rbx), %al
incq %rbx
jmp 0xafef
addq %r15, %rbx
cmpq %r15, %rbx
jbe 0xb03a
movq %r14, %rdi
callq 0xae7a
movq %r15, 0x8(%r14)
movq %rbx, 0x10(%r14)
movl $0x100, (%r14)          # imm = 0x100
jmp 0xb03c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0xe6ba
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0xb0ad
movq %rax, %rbx
movb (%rax), %al
testb %al, %al
je 0xb0ad
movq %rbx, %r14
testb %al, %al
je 0xb0a9
movsbl %al, %edi
callq 0xe35c
testb %al, %al
je 0xb099
movq %rbx, %rdi
callq 0xe6ba
cmpb $0x0, (%rax)
je 0xb0a9
movq %rax, %rbx
movb $0x20, (%r14)
incq %r14
movb (%rbx), %al
movb %al, (%r14)
incq %r14
movb 0x1(%rbx), %al
incq %rbx
jmp 0xb072
movb $0x0, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb390
cmpb $-0x45, 0x1(%rax)
jne 0xb390
cmpb $-0x41, 0x2(%rax)
jne 0xb390
movb $0x1, (%rsi)
addq $0x3, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb3e0
movl $0x1, (%rdx)
movabsq $0x1, %rax
jmp 0xb43b
cmpq $0x7ff, %rdi            # imm = 0x7FF
ja 0xb3f1
movl $0x2, (%rdx)
jmp 0xb42b
cmpq $0xffff, %rdi           # imm = 0xFFFF
ja 0xb402
movl $0x3, (%rdx)
jmp 0xb41e
cmpq $0x200000, %rdi         # imm = 0x200000
jae 0xb444
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
andl $0x0, (%rdx)
jmp 0xb442
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
andl $0x0, (%rsi)
callq 0xb4d4
testb %al, %al
je 0xb53a
cmpl $0x0, -0x14(%rbp)
setne %al
jmp 0xb572
leaq 0x5420(%rip), %rsi      # 0x10961
movq %r14, %rdi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xb572
leaq 0x5409(%rip), %rsi      # 0x10966
movq %r14, %rdi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xb576
movb %al, (%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
testb %al, %al
je 0xb83a
leaq 0x30(%rbx), %r15
movq (%r15), %r15
testq %r15, %r15
je 0xb83a
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x70(%rax)
addq $0x48, %r15
testb %al, %al
jne 0xb81e
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_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq (%r15), %r14
testq %r14, %r14
je 0xb8b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb8c6
movq %r14, %rdi
callq 0xb954
jmp 0xb897
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb8db
movq 0x48(%rax), %rax
movq %rax, 0x30(%rdi)
movq 0x38(%rdi), %rax
cmpq %rsi, %rax
jne 0xb8ec
movq 0x40(%rax), %rax
movq %rax, 0x38(%rdi)
movq 0x40(%rsi), %rax
movq 0x48(%rsi), %rcx
testq %rax, %rax
je 0xb8fd
movq %rcx, 0x48(%rax)
testq %rcx, %rcx
je 0xb906
movq %rax, 0x40(%rcx)
andq $0x0, 0x10(%rsi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb945
callq 0xae7a
movq %rbx, 0x20(%r14)
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xaee6
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb983
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_O2/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 0xb9a7
xorl %ebx, %ebx
jmp 0xb9f1
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0xb9c0
movq %rbx, %rsi
callq 0xb8c6
jmp 0xb9ca
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)
andq $0x0, 0x48(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xba0f
xorl %ebx, %ebx
jmp 0xba59
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0xba28
movq %rbx, %rsi
callq 0xb8c6
jmp 0xba32
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)
andq $0x0, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xba82
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdi, 0x10(%rsi)
je 0xba92
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 0xbaaf
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xbac4
movq %rbx, %rsi
callq 0xb8c6
jmp 0xbace
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb992
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 0xba84
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
addq $0x30, %r14
movq (%r14), %r14
testq %r14, %r14
je 0xbb3f
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
testq %rax, %rax
je 0xbb39
movq %rax, %r15
testq %rbx, %rbx
je 0xbb42
movq %r15, %rdi
addq $0x18, %rdi
callq 0xb0b2
movq %rax, %rdi
movq %rbx, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
testb %al, %al
jne 0xbb42
addq $0x48, %r14
jmp 0xbafc
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
addq $0x38, %r14
movq (%r14), %r14
testq %r14, %r14
je 0xbba7
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
testq %rax, %rax
je 0xbba1
movq %rax, %r15
testq %rbx, %rbx
je 0xbbaa
movq %r15, %rdi
addq $0x18, %rdi
callq 0xb0b2
movq %rax, %rdi
movq %rbx, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
testb %al, %al
jne 0xbbaa
addq $0x40, %r14
jmp 0xbb64
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
movq 0x48(%r14), %r14
testq %r14, %r14
je 0xbc05
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
testq %rax, %rax
je 0xbbc8
movq %rax, %r15
testq %rbx, %rbx
je 0xbc08
leaq 0x18(%r14), %rdi
callq 0xb0b2
movq %rbx, %rdi
movq %rax, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
testb %al, %al
je 0xbbc8
jmp 0xbc08
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
movq 0x40(%r14), %r14
testq %r14, %r14
je 0xbc63
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
testq %rax, %rax
je 0xbc26
movq %rax, %r15
testq %rbx, %rbx
je 0xbc66
leaq 0x18(%r14), %rdi
callq 0xb0b2
movq %rbx, %rdi
movq %rax, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
testb %al, %al
je 0xbc26
jmp 0xbc66
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbe69
leaq 0x18(%r14), %rdi
leaq 0x4b3e(%rip), %rdx      # 0x1098a
pushq $0x2
popq %rcx
movq %rbx, %rsi
callq 0xaf52
testq %rax, %rax
jne 0xbeb8
movq 0x8(%r14), %rax
movl $0xb, 0x5c(%rax)
jmp 0xbead
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 0x4afd(%rip), %rdx      # 0x10988
movq %rbx, %rsi
callq 0xaf52
testq %rax, %rax
je 0xbea2
cmpb $0x0, (%rax)
je 0xbeb6
decq %rax
jmp 0xbeb8
movq 0x8(%r14), %rax
movl $0xa, 0x5c(%rax)
movq %rbx, 0x68(%rax)
andq $0x0, 0x70(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbed4
movq 0x8(%rbx), %r14
leaq 0x18(%rbx), %rdi
callq 0xb0b2
movq %r14, %rdi
movq %rax, %rsi
callq 0xbef4
movb 0x58(%rbx), %cl
movb %cl, 0x58(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe43a
movq %rax, %r12
movq %r14, 0x8(%rax)
andq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rdi
andl $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
leaq 0xcb4a(%rip), %rax      # 0x18a88
movq %rax, (%r12)
movb $0x0, 0x58(%r12)
movq %r15, 0x50(%r12)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xaee6
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4bd6(%rip), %rdx      # 0x10c06
pushq $0x2
popq %rcx
callq 0xaf52
testq %rax, %rax
jne 0xc051
movq 0x8(%r14), %rcx
movl $0xc, 0x5c(%rcx)
movq %rbx, 0x68(%rcx)
andq $0x0, 0x70(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe3b2
movq %rax, %r12
movq %r14, 0x8(%rax)
andq $0x0, 0x10(%rax)
andl $0x0, 0x18(%rax)
leaq 0x18(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
leaq 0xc624(%rip), %rax      # 0x186f0
movq %rax, (%r12)
movq %r15, 0x50(%r12)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xaee6
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4a56(%rip), %rdx      # 0x10c0e
pushq $0x2
popq %rcx
callq 0xaf52
testq %rax, %rax
jne 0xc1d9
movq 0x8(%r14), %rcx
movl $0xd, 0x5c(%rcx)
movq %rbx, 0x68(%rcx)
andq $0x0, 0x70(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe3b2
movq %rax, %r12
movq %r14, 0x8(%rax)
andq $0x0, 0x10(%rax)
andl $0x0, 0x18(%rax)
leaq 0x18(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
leaq 0xc53c(%rip), %rax      # 0x18790
movq %rax, (%r12)
movq %r15, 0x50(%r12)
testq %rbx, %rbx
leaq 0x4911(%rip), %rsi      # 0x10b78
cmovneq %rbx, %rsi
xorl %edx, %edx
callq 0xaee6
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x48be(%rip), %rdx      # 0x10c08
pushq $0x2
popq %rcx
callq 0xaf52
testq %rax, %rax
jne 0xc36b
movq 0x8(%r14), %rcx
movl $0xe, 0x5c(%rcx)
movq %rbx, 0x68(%rcx)
andq $0x0, 0x70(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::NewUnknown(char const*)
XMLUnknown* XMLDocument::NewUnknown( const char* str )
{
    XMLUnknown* unk = new (_commentPool.Alloc()) XMLUnknown( this );
    unk->_memPool = &_commentPool;
    unk->SetValue( str );
    return unk;
}

// 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 0xe3b2
movq %rax, %r12
movq %r14, 0x8(%rax)
andq $0x0, 0x10(%rax)
andl $0x0, 0x18(%rax)
leaq 0x18(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
leaq 0xc44a(%rip), %rax      # 0x18830
movq %rax, (%r12)
movq %r15, 0x50(%r12)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xaee6
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rdi, %rbx
addq $0x8, %rdi
callq 0xafd2
testq %rax, %rax
je 0xc4fb
cmpb $0x0, (%rax)
je 0xc4fb
movq %rax, %rdi
callq 0xe6ba
testq %rax, %rax
je 0xc4fb
cmpb $0x3d, (%rax)
jne 0xc4fb
incq %rax
movq %rax, %rdi
callq 0xe6ba
movzbl (%rax), %ecx
cmpl $0x27, %ecx
je 0xc4d6
cmpl $0x22, %ecx
jne 0xc4fb
leaq -0x12(%rbp), %rdx
movb %cl, (%rdx)
movb $0x0, 0x1(%rdx)
incq %rax
addq $0x20, %rbx
movzbl %r14b, %ecx
orl $0x2, %ecx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaf52
jmp 0xc4fd
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xc133(%rip), %rax      # 0x188d0
movq %rax, (%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0xc7bb
movq 0x38(%rdi), %r14
callq 0xc7d0
movq %r14, 0x60(%rbx)
movq %r14, %rdi
jmp 0xc7a4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe27a
movq %rax, %rdi
callq 0x6ecd
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc7fb
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_O2/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 %rsi, %r14
movq %rdi, %rbx
addq $0x60, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xc854
leaq 0x8(%rbx), %rdi
callq 0xb0b2
movq %rax, %rdi
movq %r14, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
testb %al, %al
jne 0xc854
addq $0x38, %rbx
jmp 0xc829
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc85c
testq %rax, %rax
je 0xc8e9
movq %rax, %rbx
testq %r14, %r14
je 0xc8d9
leaq 0x20(%rbx), %rdi
callq 0xb0b2
movq %rax, %rdi
movq %r14, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
testb %al, %al
je 0xc8e9
addq $0x20, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb0b2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc961
movq (%rdi), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0xc961
movq 0x30(%r14), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xaee6
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xbef4
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xb9fa
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x13
popq %r14
testq %rdi, %rdi
je 0xcafa
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xcafa
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xb0b2
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb4d4
xorl %ecx, %ecx
testb %al, %al
pushq $0x12
popq %r14
cmovnel %ecx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x13
popq %r14
testq %rdi, %rdi
je 0xcb54
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xcb54
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xb0b2
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb4f2
xorl %ecx, %ecx
testb %al, %al
pushq $0x12
popq %r14
cmovnel %ecx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x13
popq %r14
testq %rdi, %rdi
je 0xcbae
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xcbae
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xb0b2
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb510
xorl %ecx, %ecx
testb %al, %al
pushq $0x12
popq %r14
cmovnel %ecx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x13
popq %r14
testq %rdi, %rdi
je 0xcc08
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xcc08
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xb0b2
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb59e
xorl %ecx, %ecx
testb %al, %al
pushq $0x12
popq %r14
cmovnel %ecx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x13
popq %r14
testq %rdi, %rdi
je 0xcc62
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xcc62
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xb0b2
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb580
xorl %ecx, %ecx
testb %al, %al
pushq $0x12
popq %r14
cmovnel %ecx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x60(%rdi), %r12
xorl %r13d, %r13d
movq %r12, %rax
movq (%rax), %r14
testq %r14, %r14
je 0xccbc
leaq 0x8(%r14), %rdi
callq 0xb0b2
movq %rax, %rdi
movq %rbx, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
testb %al, %al
jne 0xcd27
leaq 0x38(%r14), %rax
movq %r14, %r13
jmp 0xcc8e
movq %r12, -0x30(%rbp)
movl $0x100, %r12d           # imm = 0x100
movq 0x8(%r15), %rdi
addq %r12, %rdi
callq 0xe54a
movq %rax, %r14
leaq 0xbf14(%rip), %rax      # 0x18bf0
movq %rax, (%r14)
andl $0x0, 0x8(%r14)
andl $0x0, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
addq 0x8(%r15), %r12
movq %r12, 0x40(%r14)
leaq 0x38(%r13), %rax
testq %r13, %r13
cmoveq -0x30(%rbp), %rax
movq %r14, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc506
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::DeleteAttribute(char const*)
void XMLElement::DeleteAttribute( const char* name )
{
    XMLAttribute* prev = 0;
    for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
        if ( XMLUtil::StringEqual( name, a->Name() ) ) {
            if ( prev ) {
                prev->_next = a->_next;
            }
            else {
                _rootAttribute = a->_next;
            }
            DeleteAttribute( a );
            break;
        }
        prev = a;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x60, %rbx
xorl %r12d, %r12d
movq %rbx, %rax
movq (%rax), %r15
testq %r15, %r15
je 0xcd83
leaq 0x8(%r15), %rdi
callq 0xb0b2
movq %r14, %rdi
movq %rax, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
testb %al, %al
jne 0xcd8c
leaq 0x38(%r15), %rax
movq %r15, %r12
jmp 0xcd55
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38(%r12), %rax
testq %r12, %r12
movq 0x38(%r15), %rcx
cmoveq %rbx, %rax
movq %rcx, (%rax)
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc7d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::ParseDeep(char*, tinyxml2::StrPair*)
char* XMLElement::ParseDeep( char* p, StrPair* strPair )
{
    // Read the element name.
    p = XMLUtil::SkipWhiteSpace( p );
    if ( !p ) {
        return 0;
    }

    // The closing element is the </element> form. It is
    // parsed just like a regular element then deleted from
    // the DOM.
    if ( *p == '/' ) {
        _closingType = CLOSING;
        ++p;
    }

    p = _value.ParseName( p );
    if ( _value.Empty() ) {
        return 0;
    }

    p = ParseAttributes( p );
    if ( !p || !*p || _closingType ) {
        return p;
    }

    p = XMLNode::ParseDeep( p, strPair );
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xe6ba
testq %rax, %rax
je 0xcfac
cmpb $0x2f, (%rax)
jne 0xcf68
movl $0x2, 0x58(%r14)
incq %rax
leaq 0x18(%r14), %rdi
movq %rax, %rsi
callq 0xafd2
movq 0x20(%r14), %rcx
cmpq 0x28(%r14), %rcx
je 0xcfac
movq %r14, %rdi
movq %rax, %rsi
callq 0xcdb0
testq %rax, %rax
je 0xcfac
cmpb $0x0, (%rax)
je 0xcfae
cmpl $0x0, 0x58(%r14)
jne 0xcfae
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xbc74
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::ShallowClone(tinyxml2::XMLDocument*) const
XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
{
    if ( !doc ) {
        doc = _document;
    }
    XMLElement* element = doc->NewElement( Value() );					// fixme: this will always allocate memory. Intern?
    for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {
        element->SetAttribute( a->Name(), a->Value() );					// fixme: this will always allocate memory. Intern?
    }
    return element;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0xcfcd
movq 0x8(%rbx), %r14
leaq 0x18(%rbx), %rdi
callq 0xb0b2
movq %r14, %rdi
movq %rax, %rsi
callq 0xd028
movq %rax, %r14
addq $0x60, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xd019
leaq 0x8(%rbx), %rdi
callq 0xb0b2
movq %rax, %r15
leaq 0x20(%rbx), %rdi
callq 0xb0b2
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe5d2
addq $0x38, %rbx
jmp 0xcfe8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::NewElement(char const*)
XMLElement* XMLDocument::NewElement( const char* name )
{
    XMLElement* ele = new (_elementPool.Alloc()) XMLElement( this );
    ele->_memPool = &_elementPool;
    ele->SetName( name );
    return ele;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x80(%rdi), %r15
movq %r15, %rdi
callq 0xe4c2
movq %rax, %r12
movq %r14, 0x8(%rax)
andq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rdi
andl $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
leaq 0xb85e(%rip), %rax      # 0x188d0
movq %rax, (%r12)
andl $0x0, 0x58(%r12)
andq $0x0, 0x60(%r12)
movq %r15, 0x50(%r12)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xaee6
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLElement::ShallowEqual(tinyxml2::XMLNode const*) const
bool XMLElement::ShallowEqual( const XMLNode* compare ) const
{
    const XMLElement* other = compare->ToElement();
    if ( other && XMLUtil::StringEqual( other->Value(), Value() )) {

        const XMLAttribute* a=FirstAttribute();
        const XMLAttribute* b=other->FirstAttribute();

        while ( a && b ) {
            if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) {
                return false;
            }
            a = a->Next();
            b = b->Next();
        }
        if ( a || b ) {
            // different count
            return false;
        }
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x30(%rax)
testq %rax, %rax
je 0xd130
movq %rax, %r14
leaq 0x18(%rax), %rdi
callq 0xb0b2
movq %rax, %r15
leaq 0x18(%rbx), %rdi
callq 0xb0b2
movq %r15, %rdi
movq %rax, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
testb %al, %al
je 0xd130
addq $0x60, %rbx
addq $0x60, %r14
movq (%r14), %r14
movq (%rbx), %rbx
testq %r14, %r14
je 0xd13d
testq %rbx, %rbx
je 0xd13d
leaq 0x20(%rbx), %rdi
callq 0xb0b2
movq %rax, %r15
leaq 0x20(%r14), %rdi
callq 0xb0b2
movq %r15, %rdi
movq %rax, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0xe378
testb %al, %al
je 0xd130
addq $0x38, %rbx
addq $0x38, %r14
jmp 0xd0ed
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
orq %rbx, %r14
sete %al
jmp 0xd132
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::LoadFile(char const*)
XMLError XMLDocument::LoadFile( const char* filename )
{
    Clear();
    FILE* fp = callfopen( filename, "rb" );
    if ( !fp ) {
        SetError( XML_ERROR_FILE_NOT_FOUND, filename, 0 );
        return _errorID;
    }
    LoadFile( fp );
    fclose( fp );
    return _errorID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd310
leaq 0x381f(%rip), %rsi      # 0x10b9b
movq %r14, %rdi
callq 0x4240
testq %rax, %rax
je 0xd3a4
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd3c2
movq %r15, %rdi
callq 0x41f0
movl 0x5c(%rbx), %eax
jmp 0xd3b7
movl $0x3, 0x5c(%rbx)
movq %r14, 0x68(%rbx)
andq $0x0, 0x70(%rbx)
pushq $0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq