LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xee1d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%r15), %rdi
callq 0xc97e
cmpq %r14, %rax
je 0xee26
xorl %ecx, %ecx
movq %r15, %r12
movb (%r14), %sil
testb %sil, %sil
je 0xedf1
xorl %edx, %edx
cmpb (%rax,%rdx), %sil
jne 0xedf8
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
je 0xedf8
movb 0x1(%r14,%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0xedcb
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
je 0xee2b
addq %rdx, %rax
cmpb $0x0, (%rax)
jne 0xee00
jmp 0xee2b
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
je 0xee2b
movq 0x38(%r12), %r15
testq %r15, %r15
je 0xee1d
leaq 0x8(%r15), %rdi
callq 0xc97e
movq %r12, %rcx
cmpq %r14, %rax
jne 0xedbe
jmp 0xee31
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0xee31
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_O3/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 %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movb (%rsi), %r12b
testb %r12b, %r12b
js 0xf0e6
incq %r15
movzbl %r12b, %edi
callq 0x4060
testl %eax, %eax
je 0xf0d3
movb (%r15), %r12b
incq %r15
testb %r12b, %r12b
jns 0xf0b9
jmp 0xf0e3
cmpb $0x2f, %r12b
jne 0xf0e3
movl $0x2, 0x58(%r14)
jmp 0xf0e6
decq %r15
leaq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xc806
movq 0x20(%r14), %rcx
cmpq 0x28(%r14), %rcx
je 0xf12e
movq %r14, %rdi
movq %rax, %rsi
callq 0xee6c
testq %rax, %rax
je 0xf12e
cmpb $0x0, (%rax)
je 0xf130
cmpl $0x0, 0x58(%r14)
jne 0xf130
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd83c
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::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 0xf154
movq 0x8(%r14), %rbx
leaq 0x18(%r14), %rdi
callq 0xc97e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf1ba
movq %rax, %rbx
movq 0x60(%r14), %r12
testq %r12, %r12
je 0xf1ae
leaq 0x8(%r12), %rdi
callq 0xc97e
movq %rax, %r14
leaq 0x20(%r12), %rdi
callq 0xc97e
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xec7c
leaq 0x20(%rax), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xc6e0
movq 0x38(%r12), %r12
jmp 0xf16f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::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 0x107f0
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 0xa6b2(%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 0xc6e0
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::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 0xf34a
movq %rax, %r14
leaq 0x18(%rax), %rdi
callq 0xc97e
movq %rax, %r15
leaq 0x18(%rbx), %rdi
callq 0xc97e
cmpq %rax, %r15
je 0xf2b8
movb (%r15), %dl
testb %dl, %dl
je 0xf2a1
xorl %ecx, %ecx
cmpb (%rax,%rcx), %dl
jne 0xf2ac
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xf2ac
movb 0x1(%r15,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xf27d
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xf2b8
addq %rcx, %rax
cmpb $0x0, (%rax)
jne 0xf34a
jmp 0xf2b8
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
jne 0xf34a
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 0xf344
leaq 0x20(%r15), %rdi
callq 0xc97e
movq %rax, %rbx
leaq 0x20(%r14), %rdi
callq 0xc97e
cmpq %rax, %rbx
je 0xf329
movb (%rbx), %dl
testb %dl, %dl
je 0xf31a
xorl %ecx, %ecx
cmpb (%rax,%rcx), %dl
jne 0xf321
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xf321
movb 0x1(%rbx,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xf2f7
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0xf329
addq %rcx, %rax
cmpb $0x0, (%rax)
je 0xf329
jmp 0xf34a
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
jne 0xf34a
movq 0x38(%r14), %r14
movq 0x38(%r15), %r15
testq %r15, %r15
setne %al
testq %r14, %r14
setne %cl
je 0xf344
testq %r15, %r15
jne 0xf2d5
orb %cl, %al
xorb $0x1, %al
jmp 0xf34c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::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 0xf526
leaq 0x3623(%rip), %rsi      # 0x12bbb
movq %r14, %rdi
callq 0x4240
testq %rax, %rax
je 0xf5c0
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf5e4
movq %r15, %rdi
callq 0x41e0
movl 0x5c(%rbx), %eax
jmp 0xf5d8
movl $0x3, 0x5c(%rbx)
movq %r14, 0x68(%rbx)
movq $0x0, 0x70(%rbx)
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::LoadFile(_IO_FILE*)
XMLError XMLDocument::LoadFile( FILE* fp )
{
    Clear();

    fseek( fp, 0, SEEK_SET );
    if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {
        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
        return _errorID;
    }

    fseek( fp, 0, SEEK_END );
    const long filelength = ftell( fp );
    fseek( fp, 0, SEEK_SET );
    if ( filelength == -1L ) {
        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
        return _errorID;
    }

    const size_t size = filelength;
    if ( size == 0 ) {
        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
        return _errorID;
    }

    _charBuffer = new char[size+1];
    size_t read = fread( _charBuffer, 1, size, fp );
    if ( read != size ) {
        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
        return _errorID;
    }

    _charBuffer[size] = 0;

    const char* p = _charBuffer;
    p = XMLUtil::SkipWhiteSpace( p );
    p = XMLUtil::ReadBOM( p, &_writeBOM );
    if ( !p || !*p ) {
        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
        return _errorID;
    }

    ParseDeep( _charBuffer + (p-_charBuffer), 0 );
    return _errorID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf526
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4230
movq %r14, %rdi
callq 0x4340
cmpl $-0x1, %eax
je 0xf699
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x4230
movq %r14, %rdi
callq 0x4030
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4230
testq %r15, %r15
je 0xf6fa
cmpq $-0x1, %r15
je 0xf6a9
leaq 0x1(%r15), %rdi
callq 0x4040
movq %rax, 0x78(%rbx)
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4300
cmpq %r15, %rax
jne 0xf6a9
movq 0x78(%rbx), %rax
movb $0x0, (%rax,%r15)
movq 0x78(%rbx), %r14
movb (%r14), %al
testb %al, %al
js 0xf6be
movzbl %al, %edi
callq 0x4060
testl %eax, %eax
je 0xf6be
movb 0x1(%r14), %al
incq %r14
jmp 0xf680
movq %r14, %rdi
callq 0x4420
testl %eax, %eax
je 0xf616
movl $0x5, 0x5c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movl $0x5, %eax
jmp 0xf70d
movb $0x0, 0x58(%rbx)
movb (%r14), %al
cmpb $-0x11, %al
jne 0xf6e3
cmpb $-0x45, 0x1(%r14)
jne 0xf6e7
cmpb $-0x41, 0x2(%r14)
jne 0xf6e7
movb $0x1, 0x58(%rbx)
movb 0x3(%r14), %al
addq $0x3, %r14
testb %al, %al
je 0xf6fa
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *0x78(%rax)
movl 0x5c(%rbx), %eax
jmp 0xf70d
movl $0xf, 0x5c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movl $0xf, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::SaveFile(char const*, bool)
XMLError XMLDocument::SaveFile( const char* filename, bool compact )
{
    FILE* fp = callfopen( filename, "w" );
    if ( !fp ) {
        SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0 );
        return _errorID;
    }
    SaveFile(fp, compact);
    fclose( fp );
    return _errorID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x348b(%rip), %rsi      # 0x12bbe
movq %r12, %rdi
callq 0x4240
testq %rax, %rax
je 0xf75f
movq %rax, %r15
movzbl %r14b, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf780
movq %r15, %rdi
callq 0x41e0
movl 0x5c(%rbx), %eax
jmp 0xf777
movl $0x4, 0x5c(%rbx)
movq %r12, 0x68(%rbx)
movq $0x0, 0x70(%rbx)
movl $0x4, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::Parse(char const*, unsigned long)
XMLError XMLDocument::Parse( const char* p, size_t len )
{
	const char* start = p;
    Clear();

    if ( len == 0 || !p || !*p ) {
        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
        return _errorID;
    }
    if ( len == (size_t)(-1) ) {
        len = strlen( p );
    }
    _charBuffer = new char[ len+1 ];
    memcpy( _charBuffer, p, len );
    _charBuffer[len] = 0;

    p = XMLUtil::SkipWhiteSpace( p );
    p = XMLUtil::ReadBOM( p, &_writeBOM );
    if ( !p || !*p ) {
        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
        return _errorID;
    }

    ptrdiff_t delta = p - start;	// skip initial whitespace, BOM, etc.
    ParseDeep( _charBuffer+delta, 0 );
    if (_errorID) {
        // clean up now essentially dangling memory.
        // and the parse fail can put objects in the
        // pools that are dead and inaccessible.
        DeleteChildren();
        _elementPool.Clear();
        _attributePool.Clear();
        _textPool.Clear();
        _commentPool.Clear();
    }
    return _errorID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf526
testq %r12, %r12
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xf973
cmpb $0x0, (%r14)
je 0xf973
cmpq $-0x1, %r12
jne 0xf8a2
movq %r14, %rdi
callq 0x4100
movq %rax, %r12
leaq 0x1(%r12), %rdi
callq 0x4040
movq %rax, %r15
movq %rax, 0x78(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4190
movb $0x0, (%r15,%r12)
movb (%r14), %al
movq %r14, %r12
testb %al, %al
js 0xf8eb
movq %r14, %r12
movzbl %al, %edi
callq 0x4060
testl %eax, %eax
je 0xf8eb
movb 0x1(%r12), %al
incq %r12
testb %al, %al
jns 0xf8d3
movb $0x0, 0x58(%rbx)
movb (%r12), %al
cmpb $-0x11, %al
jne 0xf914
cmpb $-0x45, 0x1(%r12)
jne 0xf918
cmpb $-0x41, 0x2(%r12)
jne 0xf918
movb $0x1, 0x58(%rbx)
movb 0x3(%r12), %al
addq $0x3, %r12
testb %al, %al
je 0xf973
subq %r14, %r12
addq %r12, %r15
movq (%rbx), %rax
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq *0x78(%rax)
cmpl $0x0, 0x5c(%rbx)
je 0xf987
movq %rbx, %rdi
callq 0xd330
leaq 0x80(%rbx), %rdi
callq 0x10aa0
leaq 0x100(%rbx), %rdi
callq 0x10ae2
leaq 0x180(%rbx), %rdi
callq 0x10b24
leaq 0x200(%rbx), %rdi
callq 0x10b66
movl 0x5c(%rbx), %r14d
jmp 0xf987
movl $0xf, 0x5c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movl $0xf, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::PrintError() const
void XMLDocument::PrintError() const
{
    if ( _errorID ) {
        static const int LEN = 20;
        char buf1[LEN] = { 0 };
        char buf2[LEN] = { 0 };

        if ( _errorStr1 ) {
            TIXML_SNPRINTF( buf1, LEN, "%s", _errorStr1 );
        }
        if ( _errorStr2 ) {
            TIXML_SNPRINTF( buf2, LEN, "%s", _errorStr2 );
        }

        printf( "XMLDocument error id=%d '%s' str1=%s str2=%s\n",
                _errorID, ErrorName(), buf1, buf2 );
    }
}

// Assembly:
cmpl $0x0, 0x5c(%rdi)
je 0xfa3b
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movl %eax, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0xf9f1
leaq 0x322d(%rip), %rdx      # 0x12c0e
leaq -0x40(%rbp), %rdi
movl $0x14, %esi
xorl %eax, %eax
callq 0x4360
movq 0x70(%rbx), %rcx
testq %rcx, %rcx
je 0xfa11
leaq 0x320d(%rip), %rdx      # 0x12c0e
leaq -0x20(%rbp), %rdi
movl $0x14, %esi
xorl %eax, %eax
callq 0x4360
movl 0x5c(%rbx), %esi
leaq 0xa845(%rip), %rax      # 0x1a260
movq (%rax,%rsi,8), %rdx
leaq 0x319a(%rip), %rdi      # 0x12bc0
leaq -0x40(%rbp), %rcx
leaq -0x20(%rbp), %r8
xorl %eax, %eax
callq 0x4050
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::XMLPrinter(_IO_FILE*, bool, int)
XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :
    _elementJustOpened( false ),
    _firstElement( true ),
    _fp( file ),
    _depth( depth ),
    _textDepth( -1 ),
    _processEntities( true ),
    _compactMode( compact )
{
    for( int i=0; i<ENTITY_RANGE; ++i ) {
        _entityFlag[i] = false;
        _restrictedEntityFlag[i] = false;
    }
    for( int i=0; i<NUM_ENTITIES; ++i ) {
        TIXMLASSERT( entities[i].value < ENTITY_RANGE );
        if ( entities[i].value < ENTITY_RANGE ) {
            _entityFlag[ (int)entities[i].value ] = true;
        }
    }
    _restrictedEntityFlag[(int)'&'] = true;
    _restrictedEntityFlag[(int)'<'] = true;
    _restrictedEntityFlag[(int)'>'] = true;	// not required, but consistency is nice
    _buffer.Push( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9fac(%rip), %rax      # 0x19a00
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %r12
movq %r12, 0x10(%rdi)
movq $0xa, 0x68(%rdi)
movb $0x1, %al
movb %al, 0x70(%rdi)
movq %rsi, 0x78(%rdi)
movl %ecx, 0x80(%rdi)
movl $0xffffffff, 0x84(%rdi) # imm = 0xFFFFFFFF
movb %al, 0x88(%rdi)
movb %dl, 0x89(%rdi)
leaq 0x110(%rdi), %r14
leaq 0x118(%rdi), %r13
movq %r13, 0x110(%rdi)
movq $0x14, 0x12c(%rdi)
leaq 0x8a(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8a(%rdi)
movups %xmm0, 0x9a(%rdi)
movups %xmm0, 0xaa(%rdi)
movups %xmm0, 0xba(%rdi)
movups %xmm0, 0xca(%rdi)
movups %xmm0, 0xda(%rdi)
movups %xmm0, 0xea(%rdi)
movups %xmm0, 0xfa(%rdi)
movl $0xc, %ecx
leaq 0x9ae2(%rip), %rdx      # 0x195e0
movsbq (%rcx,%rdx), %rsi
movb $0x1, (%rax,%rsi)
addq $0x10, %rcx
cmpq $0x5c, %rcx
jne 0xfafe
movb $0x1, %al
movb %al, 0xf0(%rbx)
movb %al, 0x106(%rbx)
movb %al, 0x108(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x10d56
movq 0x110(%rbx), %rax
movslq 0x130(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x130(%rbx)
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xfb77
callq 0x4280
movq 0x10(%rbx), %rdi
cmpq %r12, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xfb90
callq 0x4280
movq %r15, %rdi
callq 0x43d0
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::Print(char const*, ...)
void XMLPrinter::Print( const char* format, ... )
{
    va_list     va;
    va_start( va, format );

    if ( _fp ) {
        vfprintf( _fp, format, va );
    }
    else {
#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
		#if defined(WINCE)
		int len = 512;
		do {
		    len = len*2;
		    char* str = new char[len]();
			len = _vsnprintf(str, len, format, va);
			delete[] str;
		}while (len < 0);
		#else
        int len = _vscprintf( format, va );
		#endif
#else
        int len = vsnprintf( 0, 0, format, va );
#endif
        // Close out and re-start the va-args
        va_end( va );
        va_start( va, format );
        char* p = _buffer.PushArr( len ) - 1;	// back up over the null terminator.
#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
		#if defined(WINCE)
		_vsnprintf( p, len+1, format, va );
		#else
		vsnprintf_s( p, len+1, _TRUNCATE, format, va );
		#endif
#else
		vsnprintf( p, len+1, format, va );
#endif
    }
    va_end( va );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xf0(%rbp), %r13
movq %rdx, 0x10(%r13)
movq %rcx, 0x18(%r13)
movq %r8, 0x20(%r13)
movq %r9, 0x28(%r13)
testb %al, %al
je 0xfbf9
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r13, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000010, %r15     # imm = 0x3000000010
movq %r15, -0x40(%rbp)
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0xfc2a
leaq -0x40(%rbp), %rdx
movq %rbx, %rsi
callq 0x42b0
jmp 0xfc9a
leaq -0x40(%rbp), %rcx
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x4150
movl %eax, %r12d
leaq -0x40(%rbp), %rax
movq %r15, (%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, %r15
leaq 0x110(%r14), %rdi
movl 0x130(%r14), %esi
addl %r12d, %esi
callq 0x10d56
movq 0x110(%r14), %rax
movslq 0x130(%r14), %rcx
leal (%rcx,%r12), %edx
movl %edx, 0x130(%r14)
leaq (%rax,%rcx), %rdi
decq %rdi
incl %r12d
movslq %r12d, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x4150
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PrintString(char const*, bool)
void XMLPrinter::PrintString( const char* p, bool restricted )
{
    // Look for runs of bytes between entities to print.
    const char* q = p;
    const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;

    if ( _processEntities ) {
        while ( *q ) {
            // Remember, char is sometimes signed. (How many times has that bitten me?)
            if ( *q > 0 && *q < ENTITY_RANGE ) {
                // Check for entities. If one is found, flush
                // the stream up until the entity, write the
                // entity, and keep looking.
                if ( flag[(unsigned)(*q)] ) {
                    while ( p < q ) {
                        Print( "%c", *p );
                        ++p;
                    }
                    for( int i=0; i<NUM_ENTITIES; ++i ) {
                        if ( entities[i].value == *q ) {
                            Print( "&%s;", entities[i].pattern );
                            break;
                        }
                    }
                    ++p;
                }
            }
            ++q;
        }
    }
    // Flush the remaining string. This will be the entire
    // string if an entity wasn't found.
    if ( !_processEntities || (q-p > 0) ) {
        Print( "%s", p );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x88(%rdi)
jne 0xfda2
movb (%r14), %al
testb %al, %al
je 0xfdc7
shll $0x6, %edx
addq %rbx, %rdx
addq $0x8a, %rdx
leaq 0x2ed1(%rip), %r12      # 0x12bf3
leaq 0x98b7(%rip), %r13      # 0x195e0
movq %r14, %r15
movq %rdx, -0x30(%rbp)
cmpb $0x3f, %al
ja 0xfd8f
movzbl %al, %ecx
cmpb $0x1, (%rdx,%rcx)
jne 0xfd8f
cmpq %r14, %r15
jae 0xfd5e
movsbl (%r15), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xfb98
incq %r15
cmpq %r14, %r15
jb 0xfd42
movb (%r14), %al
xorl %ecx, %ecx
cmpb %al, 0xc(%rcx,%r13)
je 0xfd73
addq $0x10, %rcx
cmpq $0x50, %rcx
jne 0xfd60
jmp 0xfd88
movq (%rcx,%r13), %rdx
movq %rbx, %rdi
leaq 0x2e75(%rip), %rsi      # 0x12bf6
xorl %eax, %eax
callq 0xfb98
incq %r15
movq -0x30(%rbp), %rdx
movb 0x1(%r14), %al
incq %r14
testb %al, %al
jne 0xfd30
movb 0x88(%rbx), %al
jmp 0xfdcc
movq %r14, %r15
leaq 0x2e62(%rip), %rsi      # 0x12c0e
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfb98
movb $0x1, %al
movq %r14, %r15
testb $0x1, %al
je 0xfda5
subq %r15, %r14
testq %r14, %r14
jg 0xfda5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PushHeader(bool, bool)
void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
{
    if ( writeBOM ) {
        static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
        Print( "%s", bom );
    }
    if ( writeDec ) {
        PushDeclaration( "xml version=\"1.0\"" );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
testl %esi, %esi
je 0xfe11
leaq 0x2e0e(%rip), %rsi      # 0x12c0e
leaq 0x2e44(%rip), %rdx      # 0x12c4b
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfb98
testb %r14b, %r14b
je 0xfe29
leaq 0x2dde(%rip), %rsi      # 0x12bfb
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xfe2e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PushDeclaration(char const*)
void XMLPrinter::PushDeclaration( const char* value )
{
    if ( _elementJustOpened ) {
        SealElement();
    }
    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
        Print( "\n" );
        PrintSpace( _depth );
    }
    _firstElement = false;
    Print( "<?%s?>", value );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x8(%rdi)
jne 0xfe57
movb $0x0, 0x8(%r14)
leaq 0x2ddb(%rip), %rsi      # 0x12c28
movq %r14, %rdi
xorl %eax, %eax
callq 0xfb98
cmpl $0x0, 0x84(%r14)
jns 0xfe93
cmpb $0x0, 0x70(%r14)
jne 0xfe93
cmpb $0x0, 0x89(%r14)
jne 0xfe93
leaq 0x2abc(%rip), %rsi      # 0x12935
movq %r14, %rdi
xorl %eax, %eax
callq 0xfb98
movl 0x80(%r14), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movb $0x0, 0x70(%r14)
leaq 0x2d8b(%rip), %rsi      # 0x12c2a
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xfb98
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::OpenElement(char const*, bool)
void XMLPrinter::OpenElement( const char* name, bool compactMode )
{
    if ( _elementJustOpened ) {
        SealElement();
    }
    _stack.Push( name );

    if ( _textDepth < 0 && !_firstElement && !compactMode ) {
        Print( "\n" );
    }
    if ( !compactMode ) {
        PrintSpace( _depth );
    }

    Print( "<%s", name );
    _elementJustOpened = true;
    _firstElement = false;
    ++_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0xfede
movb $0x0, 0x8(%rbx)
leaq 0x2d54(%rip), %rsi      # 0x12c28
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfb98
leaq 0x10(%rbx), %rdi
movl 0x6c(%rbx), %esi
incl %esi
callq 0x110ca
movq 0x10(%rbx), %rax
movslq 0x6c(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x6c(%rbx)
movq %r14, (%rax,%rcx,8)
cmpl $0x0, 0x84(%rbx)
jns 0xff23
testb $0x1, 0x70(%rbx)
jne 0xff23
testb %r15b, %r15b
jne 0xff23
leaq 0x2a1c(%rip), %rsi      # 0x12935
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfb98
testb %r15b, %r15b
jne 0xff37
movl 0x80(%rbx), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
leaq 0x2ccf(%rip), %rsi      # 0x12c0d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xfb98
movb $0x1, 0x8(%rbx)
movb $0x0, 0x70(%rbx)
incl 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::CloseElement(bool)
void XMLPrinter::CloseElement( bool compactMode )
{
    --_depth;
    const char* name = _stack.Pop();

    if ( _elementJustOpened ) {
        Print( "/>" );
    }
    else {
        if ( _textDepth < 0 && !compactMode) {
            Print( "\n" );
            PrintSpace( _depth );
        }
        Print( "</%s>", name );
    }

    if ( _textDepth == _depth ) {
        _textDepth = -1;
    }
    if ( _depth == 0 && !compactMode) {
        Print( "\n" );
    }
    _elementJustOpened = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl 0x80(%rdi)
movl %esi, %r14d
movq 0x10(%rdi), %rax
movslq 0x6c(%rdi), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, 0x6c(%rdi)
cmpb $0x1, 0x8(%rdi)
jne 0x10140
leaq 0x2ae3(%rip), %rsi      # 0x12c17
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfb98
jmp 0x10188
movq -0x8(%rax,%rcx,8), %r15
cmpl $0x0, 0x84(%rbx)
setns %al
orb %r14b, %al
jne 0x10174
leaq 0x27da(%rip), %rsi      # 0x12935
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfb98
movl 0x80(%rbx), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
leaq 0x2a9f(%rip), %rsi      # 0x12c1a
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xfb98
movl 0x80(%rbx), %eax
cmpl %eax, 0x84(%rbx)
jne 0x101a0
movl $0xffffffff, 0x84(%rbx) # imm = 0xFFFFFFFF
testl %eax, %eax
setne %al
orb %r14b, %al
jne 0x101bb
leaq 0x2784(%rip), %rsi      # 0x12935
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfb98
movb $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PushText(char const*, bool)
void XMLPrinter::PushText( const char* text, bool cdata )
{
    _textDepth = _depth-1;

    if ( _elementJustOpened ) {
        SealElement();
    }
    if ( cdata ) {
        Print( "<![CDATA[" );
        Print( "%s", text );
        Print( "]]>" );
    }
    else {
        PrintString( text, true );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x80(%rdi), %eax
decl %eax
movl %eax, 0x84(%rdi)
cmpb $0x1, 0x8(%rdi)
jne 0x10206
movb $0x0, 0x8(%rbx)
leaq 0x2a2c(%rip), %rsi      # 0x12c28
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfb98
testb %r15b, %r15b
je 0x1024b
leaq 0x278c(%rip), %rsi      # 0x1299e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfb98
leaq 0x29eb(%rip), %rsi      # 0x12c0e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xfb98
leaq 0x2773(%rip), %rsi      # 0x129aa
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xfb98
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xfce2
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PushComment(char const*)
void XMLPrinter::PushComment( const char* comment )
{
    if ( _elementJustOpened ) {
        SealElement();
    }
    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
        Print( "\n" );
        PrintSpace( _depth );
    }
    _firstElement = false;
    Print( "<!--%s-->", comment );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x8(%rdi)
jne 0x10401
movb $0x0, 0x8(%r14)
leaq 0x2831(%rip), %rsi      # 0x12c28
movq %r14, %rdi
xorl %eax, %eax
callq 0xfb98
cmpl $0x0, 0x84(%r14)
jns 0x1043d
cmpb $0x0, 0x70(%r14)
jne 0x1043d
cmpb $0x0, 0x89(%r14)
jne 0x1043d
leaq 0x2512(%rip), %rsi      # 0x12935
movq %r14, %rdi
xorl %eax, %eax
callq 0xfb98
movl 0x80(%r14), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movb $0x0, 0x70(%r14)
leaq 0x27d7(%rip), %rsi      # 0x12c20
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xfb98
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PushUnknown(char const*)
void XMLPrinter::PushUnknown( const char* value )
{
    if ( _elementJustOpened ) {
        SealElement();
    }
    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
        Print( "\n" );
        PrintSpace( _depth );
    }
    _firstElement = false;
    Print( "<!%s>", value );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x8(%rdi)
jne 0x10483
movb $0x0, 0x8(%r14)
leaq 0x27af(%rip), %rsi      # 0x12c28
movq %r14, %rdi
xorl %eax, %eax
callq 0xfb98
cmpl $0x0, 0x84(%r14)
jns 0x104bf
cmpb $0x0, 0x70(%r14)
jne 0x104bf
cmpb $0x0, 0x89(%r14)
jne 0x104bf
leaq 0x2490(%rip), %rsi      # 0x12935
movq %r14, %rdi
xorl %eax, %eax
callq 0xfb98
movl 0x80(%r14), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movb $0x0, 0x70(%r14)
leaq 0x2766(%rip), %rsi      # 0x12c31
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xfb98
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::VisitEnter(tinyxml2::XMLElement const&, tinyxml2::XMLAttribute const*)
bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
{
	const XMLElement*	parentElem = element.Parent()->ToElement();
	bool		compactMode = parentElem ? CompactMode(*parentElem) : _compactMode;
    OpenElement( element.Name(), compactMode );
    while ( attribute ) {
        PushAttribute( attribute->Name(), attribute->Value() );
        attribute = attribute->Next();
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rsi), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testq %rax, %rax
je 0x1053c
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x58(%rcx)
movl %eax, %r12d
jmp 0x10543
movb 0x89(%r14), %r12b
addq $0x18, %r15
movq %r15, %rdi
callq 0xc97e
movzbl %r12b, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xfeb0
testq %rbx, %rbx
je 0x1058c
leaq 0x8(%rbx), %rdi
callq 0xc97e
movq %rax, %r15
leaq 0x20(%rbx), %rdi
callq 0xc97e
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xff7c
movq 0x38(%rbx), %rbx
jmp 0x1055e
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::MemPoolT<88>::Alloc()
virtual void* Alloc() {
        if ( !_root ) {
            // Need a new block.
            Block* block = new Block();
            _blockPtrs.Push( block );

            for( int i=0; i<COUNT-1; ++i ) {
                block->chunk[i].next = &block->chunk[i+1];
            }
            block->chunk[COUNT-1].next = 0;
            _root = block->chunk;
        }
        void* result = _root;
        _root = _root->next;

        ++_currentAllocs;
        if ( _currentAllocs > _maxAllocs ) {
            _maxAllocs = _currentAllocs;
        }
        _nAllocs++;
        _nUntracked++;
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %r14
testq %r14, %r14
jne 0x1072b
movl $0xfd0, %edi            # imm = 0xFD0
callq 0x41f0
movq %rax, %r14
movl $0xfd0, %edx            # imm = 0xFD0
movq %rax, %rdi
xorl %esi, %esi
callq 0x4140
leaq 0x8(%rbx), %rdi
movl 0x64(%rbx), %esi
incl %esi
callq 0x10dc2
movq 0x8(%rbx), %rax
movslq 0x64(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x64(%rbx)
movq %r14, (%rax,%rcx,8)
movq %r14, %rax
addq $0x58, %rax
movl $0x2d, %ecx
movq %rax, -0x58(%rax)
addq $0x58, %rax
decq %rcx
jne 0x1070f
movq $0x0, 0xf78(%r14)
movq %r14, 0x68(%rbx)
movq (%r14), %rax
movq %rax, 0x68(%rbx)
movl 0x70(%rbx), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x70(%rbx)
cmpl 0x78(%rbx), %ecx
jl 0x10743
movl %eax, 0x78(%rbx)
incl 0x74(%rbx)
incl 0x7c(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::MemPoolT<104>::Clear()
void Clear() {
        // Delete the blocks.
        while( !_blockPtrs.Empty()) {
            Block* b  = _blockPtrs.Pop();
            delete b;
        }
        _root = 0;
        _currentAllocs = 0;
        _nAllocs = 0;
        _maxAllocs = 0;
        _nUntracked = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x64(%rdi), %eax
testl %eax, %eax
je 0x10acb
movq 0x8(%rbx), %rcx
leal -0x1(%rax), %edx
movl %edx, 0x64(%rbx)
cltq
movq -0x8(%rcx,%rax,8), %rdi
callq 0x41c0
movl 0x64(%rbx), %eax
jmp 0x10aac
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::DynArray<char, 20>::EnsureCapacity(int)
void EnsureCapacity( int cap ) {
        if ( cap > _allocated ) {
            int newAllocated = cap * 2;
            T* newMem = new T[newAllocated];
            memcpy( newMem, _mem, sizeof(T)*_size );	// warning: not using constructors, only works for PODs
            if ( _mem != _pool ) {
                delete [] _mem;
            }
            _mem = newMem;
            _allocated = newAllocated;
        }
    }

// Assembly:
cmpl %esi, 0x1c(%rdi)
jge 0x10dc0
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leal (%rsi,%rsi), %r12d
testl %esi, %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %r12d, %eax
movslq %eax, %rdi
callq 0x4040
movq %rax, %r14
movq (%rbx), %r15
movslq 0x20(%rbx), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4190
leaq 0x8(%rbx), %rax
cmpq %rax, %r15
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x10db1
movq %r15, %rdi
callq 0x4280
movq %r14, (%rbx)
movl %r12d, 0x1c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::MemPoolT<104>::Free(void*)
virtual void Free( void* mem ) {
        if ( !mem ) {
            return;
        }
        --_currentAllocs;
        Chunk* chunk = static_cast<Chunk*>( mem );
#ifdef DEBUG
        memset( chunk, 0xfe, sizeof(Chunk) );
#endif
        chunk->next = _root;
        _root = chunk;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x10fd9
decl 0x70(%rdi)
movq 0x68(%rdi), %rax
movq %rax, (%rsi)
movq %rsi, 0x68(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/macfergus[P]baduk/cppsrc/apps/benchmark.cpp
// Function: main
int main() {
    for (int i = 0; i < 10000; ++i) {
        auto game = baduk::newGame(9, 7.5);
        baduk::RandomBot black_bot;
        baduk::RandomBot white_bot;

        while (!game->isOver()) {
            auto next_agent =
                game->nextPlayer() == baduk::Stone::black ?
                    &black_bot :
                    &white_bot;
            const auto next_move = next_agent->selectMove(*game);

            game = game->applyMove(next_move);
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
xorl %ecx, %ecx
leaq 0x40c1(%rip), %rax      # 0x14d10
addq $0x10, %rax
movq %rax, 0x30(%rsp)
leaq 0x58(%rsp), %r13
leaq 0x48(%rsp), %rbx
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
movabsq $0x20c49ba5e353f7cf, %r12 # imm = 0x20C49BA5E353F7CF
movl %ecx, 0x1c(%rsp)
movq %rsp, %rdi
movl $0x9, %esi
movss 0x982(%rip), %xmm0      # 0x1160c
callq 0x3ba1
movq 0x30(%rsp), %rbp
movq %rbp, 0x58(%rsp)
callq 0x3040
imulq %r12
movq %rdx, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rcx
addq %rax, %rcx
movq %rcx, %rax
movabsq $0x200000005, %rdx      # imm = 0x200000005
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
subq %rdx, %rax
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
adcq %rcx, %rax
movq %rax, 0x60(%rsp)
movq %rbp, 0x48(%rsp)
callq 0x3040
imulq %r12
movq %rdx, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rcx
addq %rax, %rcx
movq %rcx, %rax
movabsq $0x200000005, %rdx      # imm = 0x200000005
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
subq %rdx, %rax
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
adcq %rcx, %rax
movq %rax, 0x50(%rsp)
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
jne 0x10db9
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %r13, %rdi
testl %eax, %eax
je 0x10d66
movq %rbx, %rdi
movq (%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq %rax, 0x38(%rsp)
movb %dl, 0x40(%rsp)
movq (%rsp), %rsi
movq (%rsi), %rax
movq %r14, %rdi
movq %r15, %rdx
callq *0x28(%rax)
movaps 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movaps %xmm0, (%rsp)
testq %rdi, %rdi
je 0x10d44
callq 0x3cc2
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x10d44
callq 0x3cc2
jmp 0x10d44
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
movl 0x1c(%rsp), %ebp
je 0x10dcc
callq 0x3cc2
incl %ebp
cmpl $0x2710, %ebp           # imm = 0x2710
movl %ebp, %ecx
jne 0x10c76
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10df3
jmp 0x10df3
jmp 0x10df3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x10e05
callq 0x3cc2
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/ebwt_build.cpp
// Function: int parseNumber<int>(int, char const*)
static int parseNumber(T lower, const char *errmsg) {
	char *endPtr= NULL;
	T t = (T)strtol(optarg, &endPtr, 10);
	if (endPtr != NULL) {
		if (t < lower) {
			cerr << errmsg << endl;
			printUsage(cerr);
			throw 1;
		}
		return t;
	}
	cerr << errmsg << endl;
	printUsage(cerr);
	throw 1;
	return -1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq 0x2e0f2(%rip), %rax     # 0x3af70
movq (%rax), %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x54b0
cmpq $0x0, (%r14)
je 0xcea1
cmpl %ebp, %eax
jl 0xcea1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2e148(%rip), %r14     # 0x3aff0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5340
movq %rax, %rdi
callq 0x5170
movq %r14, %rdi
callq 0xaaa1
movl $0x4, %edi
callq 0x5180
movl $0x1, (%rax)
movq 0x2e06e(%rip), %rsi     # 0x3af48
movq %rax, %rdi
xorl %edx, %edx
callq 0x5630
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./ebwt.h
// Function: fileSize(char const*)
static inline int64_t fileSize(const char* name) {
	std::ifstream f;
	f.open(name, std::ios_base::binary | std::ios_base::in);
	if (!f.good() || f.eof() || !f.is_open()) { return 0; }
	f.seekg(0, std::ios_base::beg);
	std::ifstream::pos_type begin_pos = f.tellg();
	f.seekg(0, std::ios_base::end);
	return static_cast<int64_t>(f.tellg() - begin_pos);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x53e0
movq %r14, %rdi
movq %rbx, %rsi
movl $0xc, %edx
callq 0x51d0
movq (%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsp,%rax)
jne 0xcfdc
leaq 0x78(%rsp), %rdi
callq 0x50b0
testb %al, %al
je 0xcfdc
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5490
movq %rsp, %rdi
callq 0x5670
movq %rax, %rbx
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x5490
movq %rsp, %rdi
callq 0x5670
movq %rax, %r14
subq %rbx, %r14
jmp 0xcfdf
xorl %r14d, %r14d
movq %rsp, %rdi
callq 0x50d0
movq %r14, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0xcff9
jmp 0xcff9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x50d0
movq %rbx, %rdi
callq 0x5680
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./diff_sample.h
// Function: EList<unsigned int, 128> getDeltaMap<unsigned int>(unsigned int, EList<unsigned int, 128> const&)
static EList<T> getDeltaMap(T v, const EList<T>& dc) {
	// Declare anchor-map-related items
	EList<T> amap;
	size_t amapEnts = 1;
	amap.resizeExact((size_t)v);
	amap.fill(0xffffffff);
	amap[0] = 0;
	// Print out difference cover (and optionally calculate
	// anchor map)
	for(size_t i = 0; i < dc.size(); i++) {
		for(size_t j = i+1; j < dc.size(); j++) {
			assert_gt(dc[j], dc[i]);
			T diffLeft  = dc[j] - dc[i];
			T diffRight = dc[i] + v - dc[j];
			assert_lt(diffLeft, v);
			assert_lt(diffRight, v);
			if(amap[diffLeft] == 0xffffffff) {
				amap[diffLeft] = dc[i];
				amapEnts++;
			}
			if(amap[diffRight] == 0xffffffff) {
				amap[diffRight] = dc[j];
				amapEnts++;
			}
		}
	}
	return amap;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, (%rdi)
leaq 0x8(%rdi), %r15
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq $0x80, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movl %esi, %esi
callq 0x1ca80
cmpq $0x0, 0x18(%r14)
je 0xd5ab
xorl %eax, %eax
movq 0x8(%r14), %rcx
movl $0xffffffff, (%rcx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
cmpq 0x18(%r14), %rax
jb 0xd597
movq (%r15), %rax
movl $0x0, (%rax)
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0xd61e
xorl %eax, %eax
movq %rax, %rcx
incq %rax
cmpq %rsi, %rax
jae 0xd619
movq %rax, %rdx
movq 0x8(%rbx), %rsi
movl (%rsi,%rdx,4), %r8d
movl (%rsi,%rcx,4), %edi
movl %r8d, %r9d
subl %edi, %r9d
movq (%r15), %rsi
cmpl $-0x1, (%rsi,%r9,4)
jne 0xd5ef
movl %edi, (%rsi,%r9,4)
movq (%r15), %rsi
movl %ebp, %r9d
subl %r8d, %r9d
addl %edi, %r9d
movl %r9d, %edi
cmpl $-0x1, (%rsi,%rdi,4)
jne 0xd60d
movq 0x8(%rbx), %r8
movl (%r8,%rdx,4), %r8d
movl %r8d, (%rsi,%rdi,4)
incq %rdx
movq 0x18(%rbx), %rsi
cmpq %rsi, %rdx
jb 0xd5cd
cmpq %rsi, %rax
jb 0xd5bf
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0xd648
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq %rbx, %rdi
callq 0x5680
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./diff_sample.h
// Function: void VSorting_worker<SString<char>>(void*)
static void VSorting_worker(void *vp)
{
        VSortingParam<TStr>* param = (VSortingParam<TStr>*)vp;
	DifferenceCoverSample<TStr>* dcs = param->dcs;
	const TStr& host = dcs->text();
	const size_t hlen = host.length();
	uint32_t v = dcs->v();
	while(true) {
	  size_t cur = 0;
	  {
	    ThreadSafe ts(param->mutex);
	    cur = *(param->cur);
	    (*param->cur)++;
	  }
	  if(cur >= param->boundaries->size()) return;
	  size_t begin = (cur == 0 ? 0 : (*param->boundaries)[cur-1]);
	  size_t end = (*param->boundaries)[cur];
	  assert_leq(begin, end);
	  if(end - begin <= 1) continue;
	  mkeyQSortSuf2(
			host,
			hlen,
			param->sPrimeArr,
			param->sPrimeSz,
			param->sPrimeOrderArr,
			4,
			begin,
			end,
			param->depth,
			v);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %r14
movq 0x18(%r14), %r15
movl 0x8(%rax), %r13d
movq 0x38(%rbx), %r12
movq %r12, %rdi
callq 0x2cb70
movq 0x30(%rbx), %rax
movq (%rax), %rbp
leaq 0x1(%rbp), %rcx
movq %rcx, (%rax)
movq %r12, %rdi
callq 0x2cbac
movq 0x28(%rbx), %rax
cmpq 0x18(%rax), %rbp
jae 0xd6f0
movq 0x8(%rax), %rcx
testq %rbp, %rbp
je 0xd6ab
leaq (%rcx,%rbp,8), %rcx
movq -0x8(%rcx), %rax
jmp 0xd6ad
xorl %eax, %eax
movq (%rcx), %r10
movq %r10, %rcx
subq %rax, %rcx
cmpq $0x2, %rcx
jb 0xd66c
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %r8
subq $0x8, %rsp
movq %r14, %rdi
movq %r15, %rsi
movl $0x4, %r9d
pushq $0x0
pushq %r13
pushq 0x20(%rbx)
pushq %r10
pushq %rax
callq 0x1d18c
addq $0x30, %rsp
jmp 0xd66c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0xdbdd