LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::Attribute(char const*) const
const char* TiXmlElement::Attribute( const char* name ) const
{
	const TiXmlAttribute* node = attributeSet.Find( name );
	if ( node )
		return node->Value();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x42f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x49bb
movq -0x20(%rbp), %rdi
callq 0x7a50
movq %rax, -0x8(%rbp)
jmp 0x49c3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::Attribute(char const*, int*) const
const char* TiXmlElement::Attribute( const char* name, int* i ) const
{
	const TiXmlAttribute* attrib = attributeSet.Find( name );
	const char* result = 0;

	if ( attrib ) {
		result = attrib->Value();
		if ( i ) {
			attrib->QueryIntValue( i );
		}
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x42f0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4a2b
movq -0x20(%rbp), %rdi
callq 0x7a50
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4a29
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a40
jmp 0x4a2b
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::Attribute(char const*, double*) const
const char* TiXmlElement::Attribute( const char* name, double* d ) const
{
	const TiXmlAttribute* attrib = attributeSet.Find( name );
	const char* result = 0;

	if ( attrib ) {
		result = attrib->Value();
		if ( d ) {
			attrib->QueryDoubleValue( d );
		}
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x42f0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4aeb
movq -0x20(%rbp), %rdi
callq 0x7a50
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4ae9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4b00
jmp 0x4aeb
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::QueryIntAttribute(char const*, int*) const
int TiXmlElement::QueryIntAttribute( const char* name, int* ival ) const
{
	const TiXmlAttribute* attrib = attributeSet.Find( name );
	if ( !attrib )
		return TIXML_NO_ATTRIBUTE;
	return attrib->QueryIntValue( ival );
}

// 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
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x42f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4b89
movl $0x1, -0x4(%rbp)
jmp 0x4b99
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4a40
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::QueryUnsignedAttribute(char const*, unsigned int*) const
int TiXmlElement::QueryUnsignedAttribute( const char* name, unsigned* value ) const
{
	const TiXmlAttribute* node = attributeSet.Find( name );
	if ( !node )
		return TIXML_NO_ATTRIBUTE;

	int ival = 0;
	int result = node->QueryIntValue( &ival );
	*value = (unsigned)ival;
	return result;
}

// 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
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x42f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4be9
movl $0x1, -0x4(%rbp)
jmp 0x4c0f
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x4a40
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::QueryBoolAttribute(char const*, bool*) const
int TiXmlElement::QueryBoolAttribute( const char* name, bool* bval ) const
{
	const TiXmlAttribute* node = attributeSet.Find( name );
	if ( !node )
		return TIXML_NO_ATTRIBUTE;
	
	int result = TIXML_WRONG_TYPE;
	if (    StringEqual( node->Value(), "true", true, TIXML_ENCODING_UNKNOWN ) 
		 || StringEqual( node->Value(), "yes", true, TIXML_ENCODING_UNKNOWN ) 
		 || StringEqual( node->Value(), "1", true, TIXML_ENCODING_UNKNOWN ) ) 
	{
		*bval = true;
		result = TIXML_SUCCESS;
	}
	else if (    StringEqual( node->Value(), "false", true, TIXML_ENCODING_UNKNOWN ) 
			  || StringEqual( node->Value(), "no", true, TIXML_ENCODING_UNKNOWN ) 
			  || StringEqual( node->Value(), "0", true, TIXML_ENCODING_UNKNOWN ) ) 
	{
		*bval = false;
		result = TIXML_SUCCESS;
	}
	return result;
}

// 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
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x42f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4c5c
movl $0x1, -0x4(%rbp)
jmp 0x4d5f
movl $0x2, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7a50
movq %rax, %rdi
leaq 0x95df(%rip), %rsi      # 0xe255
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x9540
testb $0x1, %al
jne 0x4cce
movq -0x28(%rbp), %rdi
callq 0x7a50
movq %rax, %rdi
leaq 0x95c1(%rip), %rsi      # 0xe25a
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x9540
testb $0x1, %al
jne 0x4cce
movq -0x28(%rbp), %rdi
callq 0x7a50
movq %rax, %rdi
leaq 0x9e03(%rip), %rsi      # 0xeabf
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x9540
testb $0x1, %al
jne 0x4cce
jmp 0x4cde
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movl $0x0, -0x2c(%rbp)
jmp 0x4d59
movq -0x28(%rbp), %rdi
callq 0x7a50
movq %rax, %rdi
leaq 0x956d(%rip), %rsi      # 0xe25e
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x9540
testb $0x1, %al
jne 0x4d49
movq -0x28(%rbp), %rdi
callq 0x7a50
movq %rax, %rdi
leaq 0x9550(%rip), %rsi      # 0xe264
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x9540
testb $0x1, %al
jne 0x4d49
movq -0x28(%rbp), %rdi
callq 0x7a50
movq %rax, %rdi
leaq 0x9442(%rip), %rsi      # 0xe179
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x9540
testb $0x1, %al
jne 0x4d49
jmp 0x4d57
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x2c(%rbp)
jmp 0x4d59
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::QueryDoubleAttribute(char const*, double*) const
int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const
{
	const TiXmlAttribute* attrib = attributeSet.Find( name );
	if ( !attrib )
		return TIXML_NO_ATTRIBUTE;
	return attrib->QueryDoubleValue( dval );
}

// 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
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x42f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4da9
movl $0x1, -0x4(%rbp)
jmp 0x4db9
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4b00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttributeSet::FindOrCreate(char const*)
TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const char* _name )
{
	TiXmlAttribute* attrib = Find( _name );
	if ( !attrib ) {
		attrib = new TiXmlAttribute();
		Add( attrib );
		attrib->SetName( _name );
	}
	return attrib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4ea7
movl $0x40, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x7f10
jmp 0x4e67
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x6d30
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8000
jmp 0x4ea7
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x40, %esi
callq 0x3140
jmp 0x4eb1
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3270
nopw (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttribute::Next() const
const TiXmlAttribute* TiXmlAttribute::Next() const
{
	// We are using knowledge of the sentinel. The sentinel
	// have a value or name.
	if ( next->value.empty() && next->name.empty() )
		return 0;
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x38(%rax), %rdi
addq $0x28, %rdi
callq 0x7c90
testb $0x1, %al
jne 0x5297
jmp 0x52b8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x20, %rdi
callq 0x7c90
testb $0x1, %al
jne 0x52ae
jmp 0x52b8
movq $0x0, -0x8(%rbp)
jmp 0x52c4
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::Accept(TiXmlVisitor*) const
bool TiXmlElement::Accept( TiXmlVisitor* visitor ) const
{
	if ( visitor->VisitEnter( *this, attributeSet.First() ) ) 
	{
		for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
		{
			if ( !node->Accept( visitor ) )
				break;
		}
	}
	return visitor->VisitExit( *this );
}

// 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)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x50, %rdi
callq 0x7aa0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x5310
jmp 0x534e
movq -0x20(%rbp), %rdi
callq 0x7980
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x534c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x88(%rax)
testb $0x1, %al
jne 0x533b
jmp 0x534c
jmp 0x533d
movq -0x18(%rbp), %rdi
callq 0x79a0
movq %rax, -0x18(%rbp)
jmp 0x531d
jmp 0x534e
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::Clone() const
TiXmlNode* TiXmlElement::Clone() const
{
	TiXmlElement* clone = new TiXmlElement( Value() );
	if ( !clone )
		return 0;

	CopyTo( clone );
	return clone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x90, %edi
callq 0x3130
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x7960
movq %rax, -0x30(%rbp)
jmp 0x53a1
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x4640
jmp 0x53b0
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x53e5
movq $0x0, -0x8(%rbp)
jmp 0x53fa
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x90, %esi
callq 0x3140
jmp 0x5404
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4780
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::GetText() const
const char* TiXmlElement::GetText() const
{
	const TiXmlNode* child = this->FirstChild();
	if ( child ) {
		const TiXmlText* childText = child->ToText();
		if ( childText ) {
			return childText->Value();
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7980
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5456
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5454
movq -0x20(%rbp), %rdi
callq 0x7960
movq %rax, -0x8(%rbp)
jmp 0x545e
jmp 0x5456
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::TiXmlDocument(char const*)
TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
	tabsize = 4;
	useMicrosoftBOM = false;
	value = documentName;
	ClearError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
callq 0x3680
movq -0x30(%rbp), %rdi
leaq 0xe776(%rip), %rax      # 0x13cb0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x58, %rdi
movq %rdi, -0x28(%rbp)
callq 0x78a0
jmp 0x5550
movq -0x30(%rbp), %rdi
addq $0x64, %rdi
callq 0x7b20
jmp 0x555f
movq -0x30(%rbp), %rdi
movl $0x4, 0x60(%rdi)
movb $0x0, 0x6c(%rdi)
movq -0x10(%rbp), %rsi
addq $0x38, %rdi
callq 0x79c0
jmp 0x557d
movq -0x30(%rbp), %rdi
callq 0x7b40
jmp 0x5588
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x55b1
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x78c0
movq -0x30(%rbp), %rdi
callq 0x3710
movq -0x18(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::CopyTo(TiXmlDocument*) const
void TiXmlDocument::CopyTo( TiXmlDocument* target ) const
{
	TiXmlNode::CopyTo( target );

	target->error = error;
	target->errorId = errorId;
	target->errorDesc = errorDesc;
	target->tabsize = tabsize;
	target->errorLocation = errorLocation;
	target->useMicrosoftBOM = useMicrosoftBOM;

	TiXmlNode* node = 0;
	for ( node = firstChild; node; node = node->NextSibling() )
	{
		target->LinkEndChild( node->Clone() );
	}	
}

// 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)
movq -0x10(%rbp), %rsi
callq 0x37b0
movq -0x20(%rbp), %rsi
movb 0x50(%rsi), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x50(%rax)
movl 0x54(%rsi), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x54(%rax)
addq $0x58, %rsi
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x7c00
movq -0x20(%rbp), %rax
movl 0x60(%rax), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x60(%rcx)
movq -0x10(%rbp), %rcx
movq 0x64(%rax), %rdx
movq %rdx, 0x64(%rcx)
movb 0x6c(%rax), %dl
movq -0x10(%rbp), %rcx
andb $0x1, %dl
movb %dl, 0x6c(%rcx)
movq $0x0, -0x18(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x572b
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x3890
movq -0x18(%rbp), %rdi
callq 0x7ae0
movq %rax, -0x18(%rbp)
jmp 0x56f4
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::LoadFile(char const*, TiXmlEncoding)
bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding )
{
	TIXML_STRING filename( _filename );
	value = filename;

	// reading in binary mode so that tinyxml can normalize the EOL
	FILE* file = TiXmlFOpen( value.c_str (), "rb" );	

	if ( file )
	{
		bool result = LoadFile( file, encoding );
		fclose( file );
		return result;
	}
	else
	{
		SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7b90
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x38, %rdi
callq 0x7c00
jmp 0x57ff
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
callq 0x7810
movq %rax, -0x60(%rbp)
jmp 0x5812
movq -0x60(%rbp), %rdi
leaq 0x8a97(%rip), %rsi      # 0xe2b4
callq 0x3390
movq %rax, -0x68(%rbp)
jmp 0x5828
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x5887
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x5970
movb %al, -0x69(%rbp)
jmp 0x584c
movb -0x69(%rbp), %al
andb $0x1, %al
movb %al, -0x41(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3120
jmp 0x585f
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x58ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x78c0
jmp 0x58bf
movq -0x58(%rbp), %rdi
xorl %r8d, %r8d
movl %r8d, %ecx
movl $0x2, %esi
movq %rcx, %rdx
callq 0x9c50
jmp 0x58a0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x78c0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3270
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::SaveFile(char const*) const
bool TiXmlDocument::SaveFile( const char * filename ) const
{
	// The old c stuff lives on...
	FILE* fp = TiXmlFOpen( filename, "w" );
	if ( fp )
	{
		bool result = SaveFile( fp );
		fclose( fp );
		return result;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x912e(%rip), %rsi      # 0xea51
callq 0x3390
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5958
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5c40
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3120
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x595c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::SaveFile(_IO_FILE*) const
bool TiXmlDocument::SaveFile( FILE* fp ) const
{
	if ( useMicrosoftBOM ) 
	{
		const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
		const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
		const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;

		fputc( TIXML_UTF_LEAD_0, fp );
		fputc( TIXML_UTF_LEAD_1, fp );
		fputc( TIXML_UTF_LEAD_2, fp );
	}
	Print( fp, 0 );
	return (ferror(fp) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x6c(%rax)
je 0x5c94
movb $-0x11, -0x11(%rbp)
movb $-0x45, -0x12(%rbp)
movb $-0x41, -0x13(%rbp)
movq -0x10(%rbp), %rsi
movl $0xef, %edi
callq 0x31b0
movq -0x10(%rbp), %rsi
movl $0xbb, %edi
callq 0x31b0
movq -0x10(%rbp), %rsi
movl $0xbf, %edi
callq 0x31b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
xorl %edx, %edx
callq *0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x3280
cmpl $0x0, %eax
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::Clone() const
TiXmlNode* TiXmlDocument::Clone() const
{
	TiXmlDocument* clone = new TiXmlDocument();
	if ( !clone )
		return 0;

	CopyTo( clone );
	return clone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x70, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x5470
jmp 0x5cef
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5d24
movq $0x0, -0x8(%rbp)
jmp 0x5d39
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x70, %esi
callq 0x3140
jmp 0x5d43
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5670
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::Print(_IO_FILE*, int) const
void TiXmlDocument::Print( FILE* cfile, int depth ) const
{
	assert( cfile );
	for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
	{
		node->Print( cfile, depth );
		fprintf( cfile, "\n" );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5d74
jmp 0x5d93
leaq 0x84ec(%rip), %rdi      # 0xe267
leaq 0x82b5(%rip), %rsi      # 0xe037
movl $0x47b, %edx            # imm = 0x47B
leaq 0x8587(%rip), %rcx      # 0xe315
callq 0x30e0
movq -0x28(%rbp), %rdi
callq 0x7980
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5dd9
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rdi
leaq 0x8621(%rip), %rsi      # 0xe3e4
movb $0x0, %al
callq 0x31e0
movq -0x20(%rbp), %rdi
callq 0x79a0
movq %rax, -0x20(%rbp)
jmp 0x5da0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::Accept(TiXmlVisitor*) const
bool TiXmlDocument::Accept( TiXmlVisitor* visitor ) const
{
	if ( visitor->VisitEnter( *this ) )
	{
		for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
		{
			if ( !node->Accept( visitor ) )
				break;
		}
	}
	return visitor->VisitExit( *this );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x5e08
jmp 0x5e46
movq -0x20(%rbp), %rdi
callq 0x7980
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5e44
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x88(%rax)
testb $0x1, %al
jne 0x5e33
jmp 0x5e44
jmp 0x5e35
movq -0x18(%rbp), %rdi
callq 0x79a0
movq %rax, -0x18(%rbp)
jmp 0x5e15
jmp 0x5e46
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttribute::Previous() const
const TiXmlAttribute* TiXmlAttribute::Previous() const
{
	// We are using knowledge of the sentinel. The sentinel
	// have a value or name.
	if ( prev->value.empty() && prev->name.empty() )
		return 0;
	return prev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x30(%rax), %rdi
addq $0x28, %rdi
callq 0x7c90
testb $0x1, %al
jne 0x5e87
jmp 0x5ea8
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x20, %rdi
callq 0x7c90
testb $0x1, %al
jne 0x5e9e
jmp 0x5ea8
movq $0x0, -0x8(%rbp)
jmp 0x5eb4
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttribute::Print(_IO_FILE*, int, TiXmlString*) const
void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const
{
	TIXML_STRING n, v;

	EncodeString( name, &n );
	EncodeString( value, &v );

	if (value.find ('\"') == TIXML_STRING::npos) {
		if ( cfile ) {
			fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() );
		}
		if ( str ) {
			(*str) += n; (*str) += "=\""; (*str) += v; (*str) += "\"";
		}
	}
	else {
		if ( cfile ) {
			fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() );
		}
		if ( str ) {
			(*str) += n; (*str) += "='"; (*str) += v; (*str) += "'";
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x78a0
leaq -0x30(%rbp), %rdi
callq 0x78a0
jmp 0x5ef6
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x33c0
jmp 0x5f09
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
leaq -0x30(%rbp), %rsi
callq 0x33c0
jmp 0x5f1c
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movl $0x22, %esi
callq 0x7cb0
movq %rax, -0x50(%rbp)
jmp 0x5f34
movq -0x50(%rbp), %rax
leaq 0x9079(%rip), %rcx      # 0xefb8
cmpq (%rcx), %rax
jne 0x600c
cmpq $0x0, -0x10(%rbp)
je 0x5fbc
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7810
movq %rax, -0x58(%rbp)
jmp 0x5f66
leaq -0x30(%rbp), %rdi
callq 0x7810
movq %rax, -0x68(%rbp)
jmp 0x5f75
movq -0x68(%rbp), %rcx
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rdi
leaq 0x83c2(%rip), %rsi      # 0xe34a
movb $0x0, %al
callq 0x31e0
jmp 0x5fbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x60bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x78c0
jmp 0x60bb
cmpq $0x0, -0x20(%rbp)
je 0x6007
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7ce0
jmp 0x5fd2
movq -0x20(%rbp), %rdi
leaq 0x845d(%rip), %rsi      # 0xe43a
callq 0x7d30
jmp 0x5fe4
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7ce0
jmp 0x5ff3
movq -0x20(%rbp), %rdi
leaq 0x843d(%rip), %rsi      # 0xe43b
callq 0x7d30
jmp 0x6005
jmp 0x6007
jmp 0x60a0
cmpq $0x0, -0x10(%rbp)
je 0x6053
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7810
movq %rax, -0x70(%rbp)
jmp 0x602a
leaq -0x30(%rbp), %rdi
callq 0x7810
movq %rax, -0x80(%rbp)
jmp 0x6039
movq -0x80(%rbp), %rcx
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rdi
leaq 0x8306(%rip), %rsi      # 0xe352
movb $0x0, %al
callq 0x31e0
cmpq $0x0, -0x20(%rbp)
je 0x609e
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7ce0
jmp 0x6069
movq -0x20(%rbp), %rdi
leaq 0x82e6(%rip), %rsi      # 0xe35a
callq 0x7d30
jmp 0x607b
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7ce0
jmp 0x608a
movq -0x20(%rbp), %rdi
leaq 0x82c6(%rip), %rsi      # 0xe35b
callq 0x7d30
jmp 0x609c
jmp 0x609e
jmp 0x60a0
leaq -0x30(%rbp), %rdi
callq 0x78c0
leaq -0x28(%rbp), %rdi
callq 0x78c0
addq $0x80, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x78c0
movq -0x38(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlComment::Print(_IO_FILE*, int) const
void TiXmlComment::Print( FILE* cfile, int depth ) const
{
	assert( cfile );
	for ( int i=0; i<depth; i++ )
	{
		fprintf( cfile,  "    " );
	}
	fprintf( cfile, "<!--%s-->", value.c_str() );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6224
jmp 0x6243
leaq 0x803c(%rip), %rdi      # 0xe267
leaq 0x7e05(%rip), %rsi      # 0xe037
movl $0x513, %edx            # imm = 0x513
leaq 0x8129(%rip), %rcx      # 0xe367
callq 0x30e0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x626f
movq -0x10(%rbp), %rdi
leaq 0x8044(%rip), %rsi      # 0xe2a1
movb $0x0, %al
callq 0x31e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x624a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
callq 0x7810
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x8109(%rip), %rsi      # 0xe39b
movb $0x0, %al
callq 0x31e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlComment::Clone() const
TiXmlNode* TiXmlComment::Clone() const
{
	TiXmlComment* clone = new TiXmlComment();

	if ( !clone )
		return 0;

	CopyTo( clone );
	return clone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x50, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x7d70
jmp 0x62ff
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6334
movq $0x0, -0x8(%rbp)
jmp 0x6349
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x50, %esi
callq 0x3140
jmp 0x6353
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6190
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlText::Print(_IO_FILE*, int) const
void TiXmlText::Print( FILE* cfile, int depth ) const
{
	assert( cfile );
	if ( cdata )
	{
		int i;
		fprintf( cfile, "\n" );
		for ( i=0; i<depth; i++ ) {
			fprintf( cfile, "    " );
		}
		fprintf( cfile, "<![CDATA[%s]]>\n", value.c_str() );	// unformatted output
	}
	else
	{
		TIXML_STRING buffer;
		EncodeString( value, &buffer );
		fprintf( cfile, "%s", buffer.c_str() );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6384
jmp 0x63a3
leaq 0x7edc(%rip), %rdi      # 0xe267
leaq 0x7ca5(%rip), %rsi      # 0xe037
movl $0x536, %edx            # imm = 0x536
leaq 0x8007(%rip), %rcx      # 0xe3a5
callq 0x30e0
movq -0x38(%rbp), %rax
testb $0x1, 0x50(%rax)
je 0x6417
movq -0x10(%rbp), %rdi
leaq 0x802c(%rip), %rsi      # 0xe3e4
movb $0x0, %al
callq 0x31e0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x63eb
movq -0x10(%rbp), %rdi
leaq 0x7ec8(%rip), %rsi      # 0xe2a1
movb $0x0, %al
callq 0x31e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x63c6
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x38, %rdi
callq 0x7810
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x7fc8(%rip), %rsi      # 0xe3d6
movb $0x0, %al
callq 0x31e0
jmp 0x6486
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x78a0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x38, %rdi
callq 0x33c0
jmp 0x6437
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7810
movq %rax, -0x50(%rbp)
jmp 0x644e
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rdi
leaq 0x7e4a(%rip), %rsi      # 0xe2a7
movb $0x0, %al
callq 0x31e0
leaq -0x20(%rbp), %rdi
callq 0x78c0
jmp 0x6486
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x78c0
jmp 0x648c
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlText::Clone() const
TiXmlNode* TiXmlText::Clone() const
{	
	TiXmlText* clone = 0;
	clone = new TiXmlText( "" );

	if ( !clone )
		return 0;

	CopyTo( clone );
	return clone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x58, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x7e9e(%rip), %rsi      # 0xe3e5
callq 0x7db0
jmp 0x654e
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6583
movq $0x0, -0x8(%rbp)
jmp 0x6598
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x3140
jmp 0x65a2
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x64a0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3270
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDeclaration::CopyTo(TiXmlDeclaration*) const
void TiXmlDeclaration::CopyTo( TiXmlDeclaration* target ) const
{
	TiXmlNode::CopyTo( target );

	target->version = version;
	target->encoding = encoding;
	target->standalone = standalone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x37b0
movq -0x18(%rbp), %rsi
addq $0x50, %rsi
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x7c00
movq -0x18(%rbp), %rsi
addq $0x58, %rsi
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x7c00
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x7c00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDeclaration::Clone() const
TiXmlNode* TiXmlDeclaration::Clone() const
{	
	TiXmlDeclaration* clone = new TiXmlDeclaration();

	if ( !clone )
		return 0;

	CopyTo( clone );
	return clone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x68, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x7e20
jmp 0x6aaf
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6ae4
movq $0x0, -0x8(%rbp)
jmp 0x6af9
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x68, %esi
callq 0x3140
jmp 0x6b03
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x67a0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlUnknown::Clone() const
TiXmlNode* TiXmlUnknown::Clone() const
{
	TiXmlUnknown* clone = new TiXmlUnknown();

	if ( !clone )
		return 0;

	CopyTo( clone );
	return clone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x50, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x7ed0
jmp 0x6c1f
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6c54
movq $0x0, -0x8(%rbp)
jmp 0x6c69
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x50, %esi
callq 0x3140
jmp 0x6c73
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6b90
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttributeSet::Add(TiXmlAttribute*)
void TiXmlAttributeSet::Add( TiXmlAttribute* addMe )
{
    #ifdef TIXML_USE_STL
	assert( !Find( TIXML_STRING( addMe->Name() ) ) );	// Shouldn't be multiply adding to the set.
	#else
	assert( !Find( addMe->Name() ) );	// Shouldn't be multiply adding to the set.
	#endif

	addMe->next = &sentinel;
	addMe->prev = sentinel.prev;

	sentinel.prev->next = addMe;
	sentinel.prev      = addMe;
}

// 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 0x7b00
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x42f0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6d6c
jmp 0x6d6e
jmp 0x6d8d
leaq 0x772e(%rip), %rdi      # 0xe4a3
leaq 0x72bb(%rip), %rsi      # 0xe037
movl $0x5ef, %edx            # imm = 0x5EF
leaq 0x7732(%rip), %rcx      # 0xe4ba
callq 0x30e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rax, 0x38(%rcx)
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x30(%rcx)
movq -0x10(%rbp), %rdx
movq 0x30(%rax), %rcx
movq %rdx, 0x38(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlHandle::FirstChild() const
TiXmlHandle TiXmlHandle::FirstChild() const
{
	if ( node )
	{
		TiXmlNode* child = node->FirstChild();
		if ( child )
			return TiXmlHandle( child );
	}
	return TiXmlHandle( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x6e11
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x8030
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e0f
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8050
jmp 0x6e1e
jmp 0x6e11
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8050
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlHandle::FirstChild(char const*) const
TiXmlHandle TiXmlHandle::FirstChild( const char * value ) const
{
	if ( node )
	{
		TiXmlNode* child = node->FirstChild( value );
		if ( child )
			return TiXmlHandle( child );
	}
	return TiXmlHandle( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x6e89
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x8070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6e87
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8050
jmp 0x6e96
jmp 0x6e89
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8050
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlHandle::FirstChildElement() const
TiXmlHandle TiXmlHandle::FirstChildElement() const
{
	if ( node )
	{
		TiXmlElement* child = node->FirstChildElement();
		if ( child )
			return TiXmlHandle( child );
	}
	return TiXmlHandle( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x6ef1
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x80a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6eef
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8050
jmp 0x6efe
jmp 0x6ef1
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8050
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlHandle::FirstChildElement(char const*) const
TiXmlHandle TiXmlHandle::FirstChildElement( const char * value ) const
{
	if ( node )
	{
		TiXmlElement* child = node->FirstChildElement( value );
		if ( child )
			return TiXmlHandle( child );
	}
	return TiXmlHandle( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x6f69
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x80c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6f67
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8050
jmp 0x6f76
jmp 0x6f69
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8050
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlHandle::Child(int) const
TiXmlHandle TiXmlHandle::Child( int count ) const
{
	if ( node )
	{
		int i;
		TiXmlNode* child = node->FirstChild();
		for (	i=0;
				child && i<count;
				child = child->NextSibling(), ++i )
		{
			// nothing
		}
		if ( child )
			return TiXmlHandle( child );
	}
	return TiXmlHandle( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x7016
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x8030
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x39(%rbp)
je 0x6fdb
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6fe4
jmp 0x6ffe
jmp 0x6fe6
movq -0x20(%rbp), %rdi
callq 0x7ae0
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6fc3
cmpq $0x0, -0x20(%rbp)
je 0x7014
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8050
jmp 0x7023
jmp 0x7016
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8050
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlHandle::Child(char const*, int) const
TiXmlHandle TiXmlHandle::Child( const char* value, int count ) const
{
	if ( node )
	{
		int i;
		TiXmlNode* child = node->FirstChild( value );
		for (	i=0;
				child && i<count;
				child = child->NextSibling( value ), ++i )
		{
			// nothing
		}
		if ( child )
			return TiXmlHandle( child );
	}
	return TiXmlHandle( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
je 0x70d2
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x8070
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x41(%rbp)
je 0x7093
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x709c
jmp 0x70ba
jmp 0x709e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x80f0
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x707b
cmpq $0x0, -0x28(%rbp)
je 0x70d0
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8050
jmp 0x70df
jmp 0x70d2
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8050
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlHandle::ChildElement(int) const
TiXmlHandle TiXmlHandle::ChildElement( int count ) const
{
	if ( node )
	{
		int i;
		TiXmlElement* child = node->FirstChildElement();
		for (	i=0;
				child && i<count;
				child = child->NextSiblingElement(), ++i )
		{
			// nothing
		}
		if ( child )
			return TiXmlHandle( child );
	}
	return TiXmlHandle( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x7186
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x80a0
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x39(%rbp)
je 0x714b
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x7154
jmp 0x716e
jmp 0x7156
movq -0x20(%rbp), %rdi
callq 0x8120
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7133
cmpq $0x0, -0x20(%rbp)
je 0x7184
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8050
jmp 0x7193
jmp 0x7186
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8050
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlHandle::ChildElement(char const*, int) const
TiXmlHandle TiXmlHandle::ChildElement( const char* value, int count ) const
{
	if ( node )
	{
		int i;
		TiXmlElement* child = node->FirstChildElement( value );
		for (	i=0;
				child && i<count;
				child = child->NextSiblingElement( value ), ++i )
		{
			// nothing
		}
		if ( child )
			return TiXmlHandle( child );
	}
	return TiXmlHandle( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
je 0x7242
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x80c0
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x41(%rbp)
je 0x7203
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x720c
jmp 0x722a
jmp 0x720e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8140
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x71eb
cmpq $0x0, -0x28(%rbp)
je 0x7240
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8050
jmp 0x724f
jmp 0x7242
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8050
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlPrinter::VisitEnter(TiXmlElement const&, TiXmlAttribute const*)
bool TiXmlPrinter::VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute )
{
	DoIndent();
	buffer += "<";
	buffer += element.Value();

	for( const TiXmlAttribute* attrib = firstAttribute; attrib; attrib = attrib->Next() )
	{
		buffer += " ";
		attrib->Print( 0, 0, &buffer );
	}

	if ( !element.FirstChild() ) 
	{
		buffer += " />";
		DoLineBreak();
	}
	else 
	{
		buffer += ">";
		if (    element.FirstChild()->ToText()
			  && element.LastChild() == element.FirstChild()
			  && element.FirstChild()->ToText()->CDATA() == false )
		{
			simpleTextPrint = true;
			// no DoLineBreak()!
		}
		else
		{
			DoLineBreak();
		}
	}
	++depth;	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x8170
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7249(%rip), %rsi      # 0xe519
callq 0x7d30
movq -0x10(%rbp), %rdi
callq 0x7960
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0x7d30
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7337
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
leaq 0x6f98(%rip), %rsi      # 0xe2a4
callq 0x7d30
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdi
addq $0x10, %rcx
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x5ec0
movq -0x20(%rbp), %rdi
callq 0x5270
movq %rax, -0x20(%rbp)
jmp 0x72f6
movq -0x10(%rbp), %rdi
callq 0x7980
cmpq $0x0, %rax
jne 0x7368
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
leaq 0x6f55(%rip), %rsi      # 0xe2aa
callq 0x7d30
movq -0x28(%rbp), %rdi
callq 0x81c0
jmp 0x73ef
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
leaq 0x702c(%rip), %rsi      # 0xe3a3
callq 0x7d30
movq -0x10(%rbp), %rdi
callq 0x7980
movq %rax, %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpq $0x0, %rax
je 0x73e4
movq -0x10(%rbp), %rdi
callq 0x81f0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7980
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x73e4
movq -0x10(%rbp), %rdi
callq 0x7980
movq %rax, %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %rdi
callq 0x8210
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x73e4
movq -0x28(%rbp), %rax
movb $0x1, 0xc(%rax)
jmp 0x73ed
movq -0x28(%rbp), %rdi
callq 0x81c0
jmp 0x73ef
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlPrinter::VisitExit(TiXmlElement const&)
bool TiXmlPrinter::VisitExit( const TiXmlElement& element )
{
	--depth;
	if ( !element.FirstChild() ) 
	{
		// nothing.
	}
	else 
	{
		if ( simpleTextPrint )
		{
			simpleTextPrint = false;
		}
		else
		{
			DoIndent();
		}
		buffer += "</";
		buffer += element.Value();
		buffer += ">";
		DoLineBreak();
	}
	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)
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x7980
cmpq $0x0, %rax
jne 0x7442
jmp 0x74a9
movq -0x18(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0x7456
movq -0x18(%rbp), %rax
movb $0x0, 0xc(%rax)
jmp 0x745f
movq -0x18(%rbp), %rdi
callq 0x8170
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0x70ad(%rip), %rsi      # 0xe51b
callq 0x7d30
movq -0x10(%rbp), %rdi
callq 0x7960
movq -0x18(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0x7d30
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0x6f08(%rip), %rsi      # 0xe3a3
callq 0x7d30
movq -0x18(%rbp), %rdi
callq 0x81c0
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)