LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0xd40f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd422
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
jmp 0xd3dd
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd437
movq 0x48(%rax), %rax
movq %rax, 0x30(%rdi)
movq 0x38(%rdi), %rax
cmpq %rsi, %rax
jne 0xd448
movq 0x40(%rax), %rax
movq %rax, 0x38(%rdi)
movq 0x40(%rsi), %rax
testq %rax, %rax
je 0xd459
movq 0x48(%rsi), %rcx
movq %rcx, 0x48(%rax)
movq 0x48(%rsi), %rcx
testq %rcx, %rcx
je 0xd466
movq %rax, 0x40(%rcx)
movq $0x0, 0x10(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd4c6
testb $0x2, 0x1(%rdi)
je 0xd4ad
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xd4ad
callq 0x4280
movl $0x0, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%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 0xc6e8
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd503
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_O1/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 0xd54d
xorl %ebx, %ebx
jmp 0xd5a2
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0xd566
movq %rbx, %rsi
callq 0xd422
jmp 0xd570
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x38(%r14), %rax
testq %rax, %rax
je 0xd58f
movq %rbx, 0x48(%rax)
movq %rax, 0x40(%rbx)
movq %rbx, 0x38(%r14)
movq $0x0, 0x48(%rbx)
jmp 0xd59e
movq %rbx, 0x38(%r14)
movq %rbx, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd5bf
xorl %ebx, %ebx
jmp 0xd614
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0xd5d8
movq %rbx, %rsi
callq 0xd422
jmp 0xd5e2
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x30(%r14), %rax
testq %rax, %rax
je 0xd601
movq %rbx, 0x40(%rax)
movq %rax, 0x48(%rbx)
movq %rbx, 0x30(%r14)
movq $0x0, 0x40(%rbx)
jmp 0xd610
movq %rbx, 0x38(%r14)
movq %rbx, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd63c
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdi, 0x10(%rsi)
je 0xd64c
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 0xd669
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xd67e
movq %rbx, %rsi
callq 0xd422
jmp 0xd688
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd538
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %r15, 0x40(%rbx)
movq 0x48(%r15), %rax
movq %rax, 0x48(%rbx)
movq 0x48(%r15), %rax
movq %rbx, 0x40(%rax)
movq %rbx, 0x48(%r15)
movq %r14, 0x10(%rbx)
jmp 0xd63e
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0xd769
movq %rsi, %rbx
testq %rbx, %rbx
sete %r13b
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, %r15
testq %rax, %rax
sete %cl
cmoveq %r12, %rax
orb %cl, %r13b
jne 0xd755
movq %r15, %rdi
addq $0x18, %rdi
callq 0xc988
cmpq %rbx, %rax
je 0xd740
movb (%rax), %dl
testb %dl, %dl
sete %cl
je 0xd737
cmpb (%rbx), %dl
jne 0xd737
movl $0x1, %esi
movq %rsi, %rdx
movb (%rax,%rsi), %sil
testb %sil, %sil
sete %cl
je 0xd729
cmpb (%rbx,%rdx), %sil
jne 0xd729
leaq 0x1(%rdx), %rsi
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
jne 0xd708
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %al
addq %rbx, %rdx
jmp 0xd73c
xorl %eax, %eax
movq %rbx, %rdx
testb %al, %al
je 0xd747
xorl %ecx, %ecx
movq %r15, %rax
jmp 0xd755
testb %cl, %cl
je 0xd750
cmpb $0x0, (%rdx)
je 0xd740
movb $0x1, %cl
movq %r12, %rax
testb %cl, %cl
je 0xd76b
movq 0x48(%r14), %r14
movq %rax, %r12
testq %r14, %r14
jne 0xd6c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x38(%rdi), %r14
testq %r14, %r14
je 0xd83d
movq %rsi, %rbx
testq %rbx, %rbx
sete %r13b
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, %r15
testq %rax, %rax
sete %cl
cmoveq %r12, %rax
orb %cl, %r13b
jne 0xd829
movq %r15, %rdi
addq $0x18, %rdi
callq 0xc988
cmpq %rbx, %rax
je 0xd814
movb (%rax), %dl
testb %dl, %dl
sete %cl
je 0xd80b
cmpb (%rbx), %dl
jne 0xd80b
movl $0x1, %esi
movq %rsi, %rdx
movb (%rax,%rsi), %sil
testb %sil, %sil
sete %cl
je 0xd7fd
cmpb (%rbx,%rdx), %sil
jne 0xd7fd
leaq 0x1(%rdx), %rsi
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
jne 0xd7dc
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %al
addq %rbx, %rdx
jmp 0xd810
xorl %eax, %eax
movq %rbx, %rdx
testb %al, %al
je 0xd81b
xorl %ecx, %ecx
movq %r15, %rax
jmp 0xd829
testb %cl, %cl
je 0xd824
cmpb $0x0, (%rdx)
je 0xd814
movb $0x1, %cl
movq %r12, %rax
testb %cl, %cl
je 0xd83f
movq 0x40(%r14), %r14
movq %rax, %r12
testq %r14, %r14
jne 0xd798
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%r14), %r14
testq %r14, %r14
je 0xd909
testq %rbx, %rbx
sete %r13b
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, %r15
testq %rax, %rax
sete %cl
cmoveq %r12, %rax
orb %cl, %r13b
jne 0xd8fc
leaq 0x18(%r14), %rdi
callq 0xc988
cmpq %rbx, %rax
je 0xd8e7
movb (%rbx), %dl
testb %dl, %dl
sete %cl
je 0xd8e0
cmpb (%rax), %dl
jne 0xd8e0
movl $0x1, %esi
movq %rsi, %rdx
movb (%rbx,%rsi), %sil
testb %sil, %sil
sete %cl
je 0xd8d1
cmpb (%rax,%rdx), %sil
jne 0xd8d1
leaq 0x1(%rdx), %rsi
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
jne 0xd8b0
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %sil
addq %rdx, %rax
jmp 0xd8e2
xorl %esi, %esi
testb %sil, %sil
je 0xd8ee
xorl %ecx, %ecx
movq %r15, %rax
jmp 0xd8fc
testb %cl, %cl
je 0xd8f7
cmpb $0x0, (%rax)
je 0xd8e7
movb $0x1, %cl
movq %r12, %rax
movq %rax, %r12
testb %cl, %cl
jne 0xd862
jmp 0xd90b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%r14), %r14
testq %r14, %r14
je 0xd9d5
testq %rbx, %rbx
sete %r13b
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, %r15
testq %rax, %rax
sete %cl
cmoveq %r12, %rax
orb %cl, %r13b
jne 0xd9c8
leaq 0x18(%r14), %rdi
callq 0xc988
cmpq %rbx, %rax
je 0xd9b3
movb (%rbx), %dl
testb %dl, %dl
sete %cl
je 0xd9ac
cmpb (%rax), %dl
jne 0xd9ac
movl $0x1, %esi
movq %rsi, %rdx
movb (%rbx,%rsi), %sil
testb %sil, %sil
sete %cl
je 0xd99d
cmpb (%rax,%rdx), %sil
jne 0xd99d
leaq 0x1(%rdx), %rsi
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
jne 0xd97c
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %sil
addq %rdx, %rax
jmp 0xd9ae
xorl %esi, %esi
testb %sil, %sil
je 0xd9ba
xorl %ecx, %ecx
movq %r15, %rax
jmp 0xd9c8
testb %cl, %cl
je 0xd9c3
cmpb $0x0, (%rax)
je 0xd9b3
movb $0x1, %cl
movq %r12, %rax
movq %rax, %r12
testb %cl, %cl
jne 0xd92e
jmp 0xd9d7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdd17
leaq 0x18(%r14), %rdi
leaq 0x4d8e(%rip), %rdx      # 0x12a7a
movq %rbx, %rsi
movl $0x2, %ecx
callq 0xc76c
testq %rax, %rax
jne 0xdd73
movq 0x8(%r14), %rcx
movl $0xb, 0x5c(%rcx)
movq %rbx, 0x68(%rcx)
movq $0x0, 0x70(%rcx)
jmp 0xdd73
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 0x4d3f(%rip), %rdx      # 0x12a78
movq %rbx, %rsi
callq 0xc76c
testq %rax, %rax
je 0xdd5a
movq %rax, %rcx
movq %rax, %rdx
decq %rdx
xorl %eax, %eax
cmpb $0x0, (%rcx)
cmovneq %rdx, %rax
jmp 0xdd73
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_O1/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 0xdd8e
movq 0x8(%rbx), %r14
leaq 0x18(%rbx), %rdi
callq 0xc988
movq %r14, %rdi
movq %rax, %rsi
callq 0xddae
movb 0x58(%rbx), %cl
movb %cl, 0x58(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10976
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 0xbc7a(%rip), %rax      # 0x19a78
movq %rax, (%r12)
movb $0x0, 0x58(%r12)
movq %r15, 0x50(%r12)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc6e8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4db8(%rip), %rdx      # 0x12cf6
movl $0x2, %ecx
callq 0xc76c
testq %rax, %rax
jne 0xdf64
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_O1/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 0x108da
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 0xb6fa(%rip), %rax      # 0x196e0
movq %rax, (%r12)
movq %r15, 0x50(%r12)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc6e8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4bde(%rip), %rdx      # 0x12cfe
movl $0x2, %ecx
callq 0xc76c
testq %rax, %rax
jne 0xe146
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_O1/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 0x108da
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 0xb5b8(%rip), %rax      # 0x19780
movq %rax, (%r12)
movq %r15, 0x50(%r12)
testq %rbx, %rbx
leaq 0x4a8d(%rip), %rsi      # 0x12c68
cmovneq %rbx, %rsi
xorl %edx, %edx
callq 0xc6e8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49ec(%rip), %rdx      # 0x12cf8
movl $0x2, %ecx
callq 0xc76c
testq %rax, %rax
jne 0xe332
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_O1/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 0x108da
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 0xb46c(%rip), %rax      # 0x19820
movq %rax, (%r12)
movq %r15, 0x50(%r12)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc6e8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
addq $0x8, %rdi
callq 0xc7f4
testq %rax, %rax
je 0xe535
movq %rax, %r15
movb (%rax), %al
testb %al, %al
je 0xe535
js 0xe4e2
movzbl %al, %edi
callq 0x4060
testl %eax, %eax
je 0xe4e2
movb 0x1(%r15), %al
incq %r15
testb %al, %al
jns 0xe4cb
cmpb $0x3d, (%r15)
jne 0xe535
movb 0x1(%r15), %al
incq %r15
testb %al, %al
js 0xe4ff
movzbl %al, %edi
callq 0x4060
testl %eax, %eax
jne 0xe4e8
movzbl (%r15), %eax
cmpl $0x27, %eax
je 0xe50d
cmpl $0x22, %eax
jne 0xe535
movb (%r15), %al
leaq -0x1a(%rbp), %rdx
movb %al, (%rdx)
movb $0x0, 0x1(%rdx)
incq %r15
addq $0x20, %rbx
movzbl %r14b, %ecx
orl $0x2, %ecx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc76c
jmp 0xe537
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb077(%rip), %rax      # 0x198c0
movq %rax, (%rdi)
movq 0x60(%rdi), %r12
testq %r12, %r12
je 0xe87c
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 0xe850
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10834
movq %rax, %rdi
callq 0x7ab3
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe8bf
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_O1/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 0xe95a
movq %rsi, %r14
leaq 0x8(%rbx), %rdi
callq 0xc988
cmpq %r14, %rax
je 0xe95a
movb (%rax), %dl
testb %dl, %dl
sete %cl
je 0xe93f
cmpb (%r14), %dl
jne 0xe93f
movl $0x1, %esi
movq %rsi, %rdx
movb (%rax,%rsi), %sil
testb %sil, %sil
sete %cl
je 0xe931
cmpb (%r14,%rdx), %sil
jne 0xe931
leaq 0x1(%rdx), %rsi
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
jne 0xe910
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %al
addq %r14, %rdx
jmp 0xe944
xorl %eax, %eax
movq %r14, %rdx
testb %al, %al
jne 0xe95a
testb %cl, %cl
je 0xe951
cmpb $0x0, (%rdx)
je 0xe95a
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0xe8ef
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
callq 0xe962
testq %rax, %rax
je 0xea72
movq %rax, %r14
testq %rbx, %rbx
je 0xea59
leaq 0x20(%r14), %rdi
callq 0xc988
cmpq %rbx, %rax
je 0xea59
movb (%rax), %dl
testb %dl, %dl
sete %cl
je 0xea53
cmpb (%rbx), %dl
jne 0xea53
movl $0x1, %esi
movq %rsi, %rdx
movb (%rax,%rsi), %sil
testb %sil, %sil
sete %cl
je 0xea45
cmpb (%rbx,%rdx), %sil
jne 0xea45
leaq 0x1(%rdx), %rsi
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
jne 0xea24
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %al
addq %rdx, %rbx
jmp 0xea55
xorl %eax, %eax
testb %al, %al
je 0xea69
addq $0x20, %r14
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc988
testb %cl, %cl
je 0xea72
cmpb $0x0, (%rbx)
je 0xea59
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xeaeb
movq (%rdi), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0xeaeb
movq 0x30(%r14), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xc6e8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xddae
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xd5aa
// File: /workspace/github_cpp_makefile_star2_O1/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 0xecc9
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xecc9
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xc988
leaq 0x3d94(%rip), %rsi      # 0x12a40
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_O1/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 0xed33
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xed33
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xc988
leaq 0x3d2d(%rip), %rsi      # 0x12a43
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_O1/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 0xed92
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xed92
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xc988
movq %rax, %rdi
movq %rbx, %rsi
callq 0xce46
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_O1/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 0xedfb
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xedfb
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xc988
leaq 0x3c81(%rip), %rsi      # 0x12a5f
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_O1/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 0xee65
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
je 0xee65
movq 0x30(%r15), %rdi
addq $0x18, %rdi
callq 0xc988
leaq 0x3c14(%rip), %rsi      # 0x12a5c
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_O1/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 0xef0c
movq %rax, %r14
leaq 0x8(%rax), %rdi
callq 0xc988
cmpq %rbx, %rax
je 0xef8d
movb (%rax), %dl
testb %dl, %dl
sete %cl
je 0xeee7
cmpb (%rbx), %dl
jne 0xeee7
movl $0x1, %esi
movq %rsi, %rdx
movb (%rax,%rsi), %sil
testb %sil, %sil
sete %cl
je 0xeed9
cmpb (%rbx,%rdx), %sil
jne 0xeed9
leaq 0x1(%rdx), %rsi
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
jne 0xeeb8
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %al
addq %rbx, %rdx
jmp 0xeeec
xorl %eax, %eax
movq %rbx, %rdx
testb %al, %al
jne 0xef8d
testb %cl, %cl
je 0xef01
cmpb $0x0, (%rdx)
je 0xef8d
movq 0x38(%r14), %rax
testq %rax, %rax
jne 0xee91
jmp 0xef0f
xorl %r14d, %r14d
leaq 0x60(%r15), %rax
movq %rax, -0x30(%rbp)
movl $0x100, %r13d           # imm = 0x100
movq 0x8(%r15), %rdi
addq %r13, %rdi
callq 0x10aae
xorl %ecx, %ecx
movq %rax, %r12
leaq 0xacab(%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 0xc6e8
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x60(%rdi), %r15
testq %r15, %r15
je 0xf047
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%r15), %rdi
callq 0xc988
cmpq %r14, %rax
je 0xf050
xorl %ecx, %ecx
movq %r15, %r12
movb (%r14), %sil
testb %sil, %sil
sete %dl
je 0xf01a
cmpb (%rax), %sil
jne 0xf01a
movl $0x1, %edi
movq %rdi, %rsi
movb (%r14,%rdi), %dil
testb %dil, %dil
sete %dl
je 0xf00b
cmpb (%rax,%rsi), %dil
jne 0xf00b
leaq 0x1(%rsi), %rdi
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
jne 0xefea
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
sete %dil
addq %rsi, %rax
jmp 0xf01c
xorl %edi, %edi
testb %dil, %dil
jne 0xf055
testb %dl, %dl
je 0xf02a
cmpb $0x0, (%rax)
je 0xf055
movq 0x38(%r12), %r15
testq %r15, %r15
je 0xf047
leaq 0x8(%r15), %rdi
callq 0xc988
movq %r12, %rcx
cmpq %r14, %rax
jne 0xefd2
jmp 0xf05b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0xf05b
movq %r12, %r15
movq %rcx, %r12
addq $0x60, %rbx
leaq 0x38(%r12), %rax
testq %r12, %r12
cmoveq %rbx, %rax
movq 0x38(%r15), %rcx
movq %rcx, (%rax)
movq (%r15), %rax
movq 0x40(%r15), %rbx
movq %r15, %rdi
callq *(%rax)
movq (%rbx), %rax
movq 0x20(%rax), %rax
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movb (%rsi), %al
testb %al, %al
js 0xf2a4
movzbl %al, %edi
callq 0x4060
testl %eax, %eax
je 0xf2a4
movb 0x1(%r15), %al
incq %r15
jmp 0xf28b
cmpb $0x2f, (%r15)
jne 0xf2b5
movl $0x2, 0x58(%r14)
incq %r15
leaq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xc7f4
movq 0x20(%r14), %rcx
cmpq 0x28(%r14), %rcx
je 0xf2ff
movq %r14, %rdi
movq %rax, %rsi
callq 0xf096
testq %rax, %rax
je 0xf301
cmpb $0x0, (%rax)
je 0xf301
cmpl $0x0, 0x58(%r14)
jne 0xf301
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd9e6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jne 0xf326
movq 0x8(%r14), %rbx
leaq 0x18(%r14), %rdi
callq 0xc988
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf38c
movq %rax, %rbx
movq 0x60(%r14), %r12
testq %r12, %r12
je 0xf380
leaq 0x8(%r12), %rdi
callq 0xc988
movq %rax, %r14
leaq 0x20(%r12), %rdi
callq 0xc988
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xee74
leaq 0x20(%rax), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xc6e8
movq 0x38(%r12), %r12
jmp 0xf341
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10a12
movq %rax, %r12
movq %r14, 0x8(%rax)
xorl %eax, %eax
movq %rax, 0x10(%r12)
leaq 0x18(%r12), %rdi
movl %eax, 0x18(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x30(%r12)
movups %xmm0, 0x40(%r12)
leaq 0xa4e0(%rip), %rcx      # 0x198c0
movq %rcx, (%r12)
movl %eax, 0x58(%r12)
movq %rax, 0x60(%r12)
movq %r15, 0x50(%r12)
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc6e8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf553
movq %rax, %r14
leaq 0x18(%rax), %rdi
callq 0xc988
movq %rax, %r15
leaq 0x18(%rbx), %rdi
callq 0xc988
cmpq %rax, %r15
je 0xf494
movb (%r15), %dl
testb %dl, %dl
sete %cl
je 0xf489
cmpb (%rax), %dl
jne 0xf489
movl $0x1, %esi
movq %rsi, %rdx
movb (%r15,%rsi), %sil
testb %sil, %sil
sete %cl
je 0xf47a
cmpb (%rax,%rdx), %sil
jne 0xf47a
leaq 0x1(%rdx), %rsi
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
jne 0xf459
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %sil
addq %rdx, %rax
jmp 0xf48b
xorl %esi, %esi
testb %sil, %sil
je 0xf546
movq 0x60(%r14), %r14
movq 0x60(%rbx), %r15
testq %r15, %r15
setne %al
testq %r14, %r14
setne %cl
movl %ecx, %edx
andb %al, %dl
cmpb $0x1, %dl
jne 0xf540
leaq 0x20(%r15), %rdi
callq 0xc988
movq %rax, %rbx
leaq 0x20(%r14), %rdi
callq 0xc988
cmpq %rax, %rbx
je 0xf521
movb (%rbx), %dl
testb %dl, %dl
sete %cl
je 0xf511
cmpb (%rax), %dl
jne 0xf511
movl $0x1, %esi
movq %rsi, %rdx
movb (%rbx,%rsi), %sil
testb %sil, %sil
sete %cl
je 0xf502
cmpb (%rax,%rdx), %sil
jne 0xf502
leaq 0x1(%rdx), %rsi
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
jne 0xf4e1
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %sil
addq %rdx, %rax
jmp 0xf513
xorl %esi, %esi
testb %sil, %sil
jne 0xf521
testb %cl, %cl
je 0xf553
cmpb $0x0, (%rax)
jne 0xf553
movq 0x38(%r14), %r14
movq 0x38(%r15), %r15
testq %r15, %r15
setne %al
testq %r14, %r14
setne %cl
je 0xf540
testq %r15, %r15
jne 0xf4b5
orb %cl, %al
xorb $0x1, %al
jmp 0xf555
testb %cl, %cl
je 0xf553
cmpb $0x0, (%rax)
je 0xf494
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf72e
leaq 0x34eb(%rip), %rsi      # 0x12c8b
movq %r14, %rdi
callq 0x4240
testq %rax, %rax
je 0xf7c5
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf7e6
movq %r15, %rdi
callq 0x41e0
jmp 0xf7d8
movl $0x3, 0x5c(%rbx)
movq %r14, 0x68(%rbx)
movq $0x0, 0x70(%rbx)
movl 0x5c(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq