LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x19a00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c060
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x1c06d
movq $0x0, -0x8(%rbp)
jmp 0x1c124
movq -0x18(%rbp), %rdi
callq 0x1eeb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c08d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x1c09a
movq $0x0, -0x8(%rbp)
jmp 0x1c124
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1eeb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x1c0d5
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x1c0d5
movq $0x0, -0x8(%rbp)
jmp 0x1c124
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x1b(%rbp)
movb $0x0, -0x1a(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
leaq -0x1b(%rbp), %rdx
movb -0x19(%rbp), %r8b
movl $0x2, %ecx
movl $0x3, %eax
testb $0x1, %r8b
cmovnel %eax, %ecx
callq 0x19950
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x162b5(%rip), %rcx     # 0x32820
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x1c5a6
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rcx
movq 0x38(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq 0x60(%rax), %rdi
callq 0x1c5c0
jmp 0x1c598
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x60(%rax)
jmp 0x1c572
movq -0x18(%rbp), %rdi
callq 0x1aa50
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8d10
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1c5d5
jmp 0x1c5f8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c68d
movq -0x20(%rbp), %rdi
callq 0x1bfe0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x1ef10
testb $0x1, %al
jne 0x1c673
jmp 0x1c67d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c695
jmp 0x1c67f
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1c64c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c6a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1c746
movq $0x0, -0x8(%rbp)
jmp 0x1c784
cmpq $0x0, -0x20(%rbp)
je 0x1c76d
movq -0x28(%rbp), %rdi
callq 0x1c000
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x1ef10
testb $0x1, %al
jne 0x1c76d
jmp 0x1c77c
movq -0x28(%rbp), %rdi
callq 0x1c000
movq %rax, -0x8(%rbp)
jmp 0x1c784
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x8630
cmpq $0x0, %rax
je 0x1c844
movq -0x20(%rbp), %rdi
callq 0x8630
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, %rax
je 0x1c844
movq -0x20(%rbp), %rdi
callq 0x8630
movq %rax, %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1abe0
jmp 0x1c86a
movq -0x20(%rbp), %rdi
callq 0x1f4a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1b760
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1ada0
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1f340
cmpq $0x0, %rax
je 0x1caa5
movq -0x28(%rbp), %rdi
callq 0x1f340
movq %rax, %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpq $0x0, %rax
je 0x1caa5
movq -0x28(%rbp), %rdi
callq 0x1f340
movq %rax, %rdi
callq 0x1abc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a4c0
testb $0x1, %al
jne 0x1ca93
jmp 0x1ca9c
movl $0x0, -0x4(%rbp)
jmp 0x1caac
movl $0x12, -0x4(%rbp)
jmp 0x1caac
movl $0x13, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1f340
cmpq $0x0, %rax
je 0x1cb35
movq -0x28(%rbp), %rdi
callq 0x1f340
movq %rax, %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpq $0x0, %rax
je 0x1cb35
movq -0x28(%rbp), %rdi
callq 0x1f340
movq %rax, %rdi
callq 0x1abc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a500
testb $0x1, %al
jne 0x1cb23
jmp 0x1cb2c
movl $0x0, -0x4(%rbp)
jmp 0x1cb3c
movl $0x12, -0x4(%rbp)
jmp 0x1cb3c
movl $0x13, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1f340
cmpq $0x0, %rax
je 0x1cbc5
movq -0x28(%rbp), %rdi
callq 0x1f340
movq %rax, %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpq $0x0, %rax
je 0x1cbc5
movq -0x28(%rbp), %rdi
callq 0x1f340
movq %rax, %rdi
callq 0x1abc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a540
testb $0x1, %al
jne 0x1cbb3
jmp 0x1cbbc
movl $0x0, -0x4(%rbp)
jmp 0x1cbcc
movl $0x12, -0x4(%rbp)
jmp 0x1cbcc
movl $0x13, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1f340
cmpq $0x0, %rax
je 0x1cc55
movq -0x28(%rbp), %rdi
callq 0x1f340
movq %rax, %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpq $0x0, %rax
je 0x1cc55
movq -0x28(%rbp), %rdi
callq 0x1f340
movq %rax, %rdi
callq 0x1abc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a630
testb $0x1, %al
jne 0x1cc43
jmp 0x1cc4c
movl $0x0, -0x4(%rbp)
jmp 0x1cc5c
movl $0x12, -0x4(%rbp)
jmp 0x1cc5c
movl $0x13, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1f340
cmpq $0x0, %rax
je 0x1cce5
movq -0x28(%rbp), %rdi
callq 0x1f340
movq %rax, %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpq $0x0, %rax
je 0x1cce5
movq -0x28(%rbp), %rdi
callq 0x1f340
movq %rax, %rdi
callq 0x1abc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a5f0
testb $0x1, %al
jne 0x1ccd3
jmp 0x1ccdc
movl $0x0, -0x4(%rbp)
jmp 0x1ccec
movl $0x12, -0x4(%rbp)
jmp 0x1ccec
movl $0x13, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1cd71
movq -0x20(%rbp), %rdi
callq 0x1bfe0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x1ef10
testb $0x1, %al
jne 0x1cd57
jmp 0x1cd59
jmp 0x1cd71
jmp 0x1cd5b
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1cd30
cmpq $0x0, -0x20(%rbp)
jne 0x1cdf3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x1f4c0
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
callq 0x1f5c0
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rcx
addq $0x100, %rcx            # imm = 0x100
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x1cdcc
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x1cdd8
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c130
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1cea1
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1bfe0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x1ef10
testb $0x1, %al
jne 0x1ce57
jmp 0x1ce8b
cmpq $0x0, -0x18(%rbp)
je 0x1ce70
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x1ce80
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rdi
callq 0x1c5c0
jmp 0x1cea1
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1ce28
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1eeb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1d11d
movq $0x0, -0x8(%rbp)
jmp 0x1d1c4
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x1d140
movq -0x28(%rbp), %rax
movl $0x2, 0x58(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x19a00
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0x1f420
testb $0x1, %al
jne 0x1d168
jmp 0x1d172
movq $0x0, -0x8(%rbp)
jmp 0x1d1c4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ceb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1d19d
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1d19d
movq -0x28(%rbp), %rax
cmpl $0x0, 0x58(%rax)
je 0x1d1a7
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d1c4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1b1f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1d1fb
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x1abc0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x1d280
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x1f640
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1d26d
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1bfe0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c000
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x1f660
movq -0x20(%rbp), %rdi
callq 0x1f6a0
movq %rax, -0x20(%rbp)
jmp 0x1d229
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x80, %rdi
callq 0x1f240
movq -0x20(%rbp), %rsi
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x1c500
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rax, -0x18(%rbp)
addq $0x80, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1fa00
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1d3f2
movq -0x20(%rbp), %rdi
callq 0x1abc0
movq -0x38(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x1abc0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x1ef10
testb $0x1, %al
jne 0x1d351
jmp 0x1d3f2
movq -0x38(%rbp), %rdi
callq 0x1f640
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1f640
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x41(%rbp)
je 0x1d382
cmpq $0x0, -0x30(%rbp)
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1d38b
jmp 0x1d3d8
movq -0x28(%rbp), %rdi
callq 0x1c000
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1c000
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x1ef10
testb $0x1, %al
jne 0x1d3bc
movb $0x0, -0x1(%rbp)
jmp 0x1d3f6
movq -0x28(%rbp), %rdi
callq 0x1f6a0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1f6a0
movq %rax, -0x30(%rbp)
jmp 0x1d36b
cmpq $0x0, -0x28(%rbp)
jne 0x1d3e6
cmpq $0x0, -0x30(%rbp)
je 0x1d3ec
movb $0x0, -0x1(%rbp)
jmp 0x1d3f6
movb $0x1, -0x1(%rbp)
jmp 0x1d3f6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1d640
movq -0x18(%rbp), %rdi
leaq 0x5584(%rip), %rsi      # 0x22c7c
callq 0x1d760
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1d72a
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b580
movq -0x28(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1d74a
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d790
movq -0x20(%rbp), %rdi
callq 0x4260
movq -0x28(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x52c5(%rip), %rsi      # 0x22c7f
callq 0x1d760
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1d9ec
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b580
movq -0x30(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1da14
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x1da20
movq -0x28(%rbp), %rdi
callq 0x4260
movq -0x30(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::Print(tinyxml2::XMLPrinter*) const
void XMLDocument::Print( XMLPrinter* streamer ) const
{
    XMLPrinter stdStreamer( stdout );
    if ( !streamer ) {
        streamer = &stdStreamer;
    }
    Accept( streamer );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x160(%rbp)
movq 0x154c3(%rip), %rax     # 0x32fb8
movq (%rax), %rsi
leaq -0x148(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x1de00
cmpq $0x0, -0x10(%rbp)
jne 0x1db1a
leaq -0x148(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x160(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
jmp 0x1db30
leaq -0x148(%rbp), %rdi
callq 0x1fa80
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x150(%rbp)
movl %eax, -0x154(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x1fa80
movq -0x150(%rbp), %rdi
callq 0x4470
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, 0x5c(%rax)
je 0x1dded
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x4170
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x4170
movq -0x48(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x1dd98
movq -0x48(%rbp), %rax
leaq -0x20(%rbp), %rdi
movq 0x68(%rax), %rcx
movl $0x14, %esi
leaq 0x4f3e(%rip), %rdx      # 0x22ccf
movb $0x0, %al
callq 0x4410
movq -0x48(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x1ddc2
movq -0x48(%rbp), %rax
leaq -0x40(%rbp), %rdi
movq 0x70(%rax), %rcx
movl $0x14, %esi
leaq 0x4f14(%rip), %rdx      # 0x22ccf
movb $0x0, %al
callq 0x4410
movq -0x48(%rbp), %rdi
movl 0x5c(%rdi), %eax
movl %eax, -0x4c(%rbp)
callq 0x1dd10
movl -0x4c(%rbp), %esi
movq %rax, %rdx
leaq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %r8
leaq 0x4e9b(%rip), %rdi      # 0x22c81
movb $0x0, %al
callq 0x4060
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1fd10
movq -0x40(%rbp), %rdi
leaq 0x14b3e(%rip), %rax     # 0x32970
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x38(%rbp)
callq 0x1fd30
jmp 0x1de48
movq -0x40(%rbp), %rdi
movb $0x1, 0x70(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x78(%rdi)
movl -0x18(%rbp), %eax
movl %eax, 0x80(%rdi)
movl $0xffffffff, 0x84(%rdi) # imm = 0xFFFFFFFF
movb $0x1, 0x88(%rdi)
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, 0x89(%rdi)
addq $0x110, %rdi            # imm = 0x110
movq %rdi, -0x48(%rbp)
callq 0x1fd60
jmp 0x1de8f
movl $0x0, -0x28(%rbp)
cmpl $0x40, -0x28(%rbp)
jge 0x1dee5
movq -0x40(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x0, 0x8a(%rax,%rcx)
movslq -0x28(%rbp), %rcx
movb $0x0, 0xca(%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1de96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1df8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1df83
movl $0x0, -0x2c(%rbp)
cmpl $0x5, -0x2c(%rbp)
jge 0x1df3f
movslq -0x2c(%rbp), %rcx
leaq 0x14653(%rip), %rax     # 0x32550
shlq $0x4, %rcx
addq %rcx, %rax
movsbl 0xc(%rax), %eax
cmpl $0x40, %eax
jge 0x1df32
movq -0x40(%rbp), %rax
movslq -0x2c(%rbp), %rdx
leaq 0x14634(%rip), %rcx     # 0x32550
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0xc(%rcx), %ecx
movslq %ecx, %rcx
movb $0x1, 0x8a(%rax,%rcx)
jmp 0x1df34
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1deec
movq -0x40(%rbp), %rdi
movb $0x1, 0xf0(%rdi)
movb $0x1, 0x106(%rdi)
movb $0x1, 0x108(%rdi)
addq $0x110, %rdi            # imm = 0x110
xorl %esi, %esi
callq 0x1fd90
jmp 0x1df68
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1fde0
movq -0x38(%rbp), %rdi
callq 0x1fe30
movq -0x40(%rbp), %rdi
callq 0x20290
movq -0x20(%rbp), %rdi
callq 0x4470
nop
// File: 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
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x1dfdb
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 %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x30(%rbp), %rcx
leaq -0xf0(%rbp), %rdx
movq %rdx, 0x10(%rcx)
leaq 0x10(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movl $0x30, 0x4(%rcx)
movl $0x10, (%rcx)
cmpq $0x0, 0x78(%rax)
je 0x1e04f
movq -0xf8(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4350
jmp 0x1e0c6
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x41b0
movq -0xf8(%rbp), %rdi
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
addq $0x110, %rdi            # imm = 0x110
movl -0x34(%rbp), %esi
callq 0x1fe80
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x41b0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1e303
movq -0x18(%rbp), %rdi
leaq 0x49da(%rip), %rsi      # 0x22ccf
leaq 0x4674(%rip), %rdx      # 0x22970
movb $0x0, %al
callq 0x1dfa0
testb $0x1, -0xa(%rbp)
je 0x1e319
movq -0x18(%rbp), %rdi
leaq 0x49a8(%rip), %rsi      # 0x22cbc
callq 0x1e320
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8(%rax)
je 0x1e347
movq -0x18(%rbp), %rdi
callq 0x1e470
movq -0x18(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jge 0x1e38d
movq -0x18(%rbp), %rax
testb $0x1, 0x70(%rax)
jne 0x1e38d
movq -0x18(%rbp), %rax
testb $0x1, 0x89(%rax)
jne 0x1e38d
movq -0x18(%rbp), %rdi
leaq 0x45ba(%rip), %rsi      # 0x22930
movb $0x0, %al
callq 0x1dfa0
movq -0x18(%rbp), %rdi
movl 0x80(%rdi), %esi
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x18(%rbp), %rdi
movb $0x0, 0x70(%rdi)
movq -0x10(%rbp), %rdx
leaq 0x494b(%rip), %rsi      # 0x22ceb
movb $0x0, %al
callq 0x1dfa0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x8(%rax)
je 0x1e3de
movq -0x20(%rbp), %rdi
callq 0x1e470
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x1fed0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jge 0x1e41e
movq -0x20(%rbp), %rax
testb $0x1, 0x70(%rax)
jne 0x1e41e
testb $0x1, -0x11(%rbp)
jne 0x1e41e
movq -0x20(%rbp), %rdi
leaq 0x4519(%rip), %rsi      # 0x22930
movb $0x0, %al
callq 0x1dfa0
testb $0x1, -0x11(%rbp)
jne 0x1e434
movq -0x20(%rbp), %rdi
movl 0x80(%rdi), %esi
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x488b(%rip), %rsi      # 0x22cce
movb $0x0, %al
callq 0x1dfa0
movq -0x20(%rbp), %rax
movb $0x1, 0x8(%rax)
movb $0x0, 0x70(%rax)
movl 0x80(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x80(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl 0x80(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x80(%rdi)
addq $0x10, %rdi
callq 0x1ff20
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
testb $0x1, 0x8(%rax)
je 0x1e6d9
movq -0x20(%rbp), %rdi
leaq 0x4608(%rip), %rsi      # 0x22cd8
movb $0x0, %al
callq 0x1dfa0
jmp 0x1e724
movq -0x20(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jge 0x1e70e
testb $0x1, -0x9(%rbp)
jne 0x1e70e
movq -0x20(%rbp), %rdi
leaq 0x4239(%rip), %rsi      # 0x22930
movb $0x0, %al
callq 0x1dfa0
movq -0x20(%rbp), %rdi
movl 0x80(%rdi), %esi
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x45be(%rip), %rsi      # 0x22cdb
movb $0x0, %al
callq 0x1dfa0
movq -0x20(%rbp), %rcx
movl 0x84(%rcx), %eax
cmpl 0x80(%rcx), %eax
jne 0x1e744
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x84(%rax) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
cmpl $0x0, 0x80(%rax)
jne 0x1e769
testb $0x1, -0x9(%rbp)
jne 0x1e769
movq -0x20(%rbp), %rdi
leaq 0x41ce(%rip), %rsi      # 0x22930
movb $0x0, %al
callq 0x1dfa0
movq -0x20(%rbp), %rax
movb $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x80(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x84(%rax)
testb $0x1, 0x8(%rax)
je 0x1e7bd
movq -0x20(%rbp), %rdi
callq 0x1e470
testb $0x1, -0x11(%rbp)
je 0x1e7ff
movq -0x20(%rbp), %rdi
leaq 0x4291(%rip), %rsi      # 0x22a5f
movb $0x0, %al
callq 0x1dfa0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x44eb(%rip), %rsi      # 0x22ccf
movb $0x0, %al
callq 0x1dfa0
movq -0x20(%rbp), %rdi
leaq 0x4275(%rip), %rsi      # 0x22a6b
movb $0x0, %al
callq 0x1dfa0
jmp 0x1e811
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x1e120
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8(%rax)
je 0x1ea07
movq -0x18(%rbp), %rdi
callq 0x1e470
movq -0x18(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jge 0x1ea4d
movq -0x18(%rbp), %rax
testb $0x1, 0x70(%rax)
jne 0x1ea4d
movq -0x18(%rbp), %rax
testb $0x1, 0x89(%rax)
jne 0x1ea4d
movq -0x18(%rbp), %rdi
leaq 0x3efa(%rip), %rsi      # 0x22930
movb $0x0, %al
callq 0x1dfa0
movq -0x18(%rbp), %rdi
movl 0x80(%rdi), %esi
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x18(%rbp), %rdi
movb $0x0, 0x70(%rdi)
movq -0x10(%rbp), %rdx
leaq 0x4281(%rip), %rsi      # 0x22ce1
movb $0x0, %al
callq 0x1dfa0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8(%rax)
je 0x1ea97
movq -0x18(%rbp), %rdi
callq 0x1e470
movq -0x18(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jge 0x1eadd
movq -0x18(%rbp), %rax
testb $0x1, 0x70(%rax)
jne 0x1eadd
movq -0x18(%rbp), %rax
testb $0x1, 0x89(%rax)
jne 0x1eadd
movq -0x18(%rbp), %rdi
leaq 0x3e6a(%rip), %rsi      # 0x22930
movb $0x0, %al
callq 0x1dfa0
movq -0x18(%rbp), %rdi
movl 0x80(%rdi), %esi
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x18(%rbp), %rdi
movb $0x0, 0x70(%rdi)
movq -0x10(%rbp), %rdx
leaq 0x4202(%rip), %rsi      # 0x22cf2
movb $0x0, %al
callq 0x1dfa0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::VisitEnter(tinyxml2::XMLDocument const&)
bool XMLPrinter::VisitEnter( const XMLDocument& doc )
{
    _processEntities = doc.ProcessEntities();
    if ( doc.HasBOM() ) {
        PushHeader( true, false );
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f460
movb %al, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x88(%rax)
movq -0x10(%rbp), %rdi
callq 0x1ff50
testb $0x1, %al
jne 0x1eb3f
jmp 0x1eb4f
movq -0x18(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1e2c0
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ff70
movq %rax, %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1ebac
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x58(%rax)
movb %al, -0x31(%rbp)
jmp 0x1ebb9
movq -0x30(%rbp), %rax
movb 0x89(%rax), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
callq 0x82a0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x1e3b0
cmpq $0x0, -0x18(%rbp)
je 0x1ec1a
movq -0x18(%rbp), %rdi
callq 0x1bfe0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c000
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x1e4a0
movq -0x18(%rbp), %rdi
callq 0x1f6a0
movq %rax, -0x18(%rbp)
jmp 0x1ebde
movb $0x1, %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::StrPair::Set(char*, char*, int)
void Set( char* start, char* end, int flags ) {
        Reset();
        _start  = start;
        _end    = end;
        _flags  = flags | NEEDS_FLUSH;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x19800
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLUtil::IsNameChar(unsigned char)
inline static bool IsNameChar( unsigned char ch ) {
        return IsNameStartChar( ch )
               || isdigit( ch )
               || ch == '.'
               || ch == '-';
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %edi
callq 0x1ede0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x2(%rbp)
jne 0x1eea3
movzbl -0x1(%rbp), %edi
callq 0x4220
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2(%rbp)
jne 0x1eea3
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2e, %ecx
movb %al, -0x2(%rbp)
je 0x1eea3
movzbl -0x1(%rbp), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLUtil::StringEqual(char const*, char const*, int)
inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX )  {
        int n = 0;
        if ( p == q ) {
            return true;
        }
        while( *p && *q && *p == *q && n<nChar ) {
            ++p;
            ++q;
            ++n;
        }
        if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x1ef39
movb $0x1, -0x1(%rbp)
jmp 0x1efd0
jmp 0x1ef3b
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x1ef7a
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x1ef7a
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movq -0x18(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jne 0x1ef7a
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1ef83
jmp 0x1efa6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1ef3b
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x1efc6
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1efcc
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1efcc
movb $0x1, -0x1(%rbp)
jmp 0x1efd0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)