LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::NextSiblingElement(char const*) const
const TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const
{
	const TiXmlNode* node;

	for (	node = NextSibling( _value );
			node;
			node = node->NextSibling( _value ) )
	{
		if ( node->ToElement() )
			return node->ToElement();
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
je 0x3fa2
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x3f48
jmp 0x3f84
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
je 0x3fa2
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x3f67
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testq %rax, %rax
je 0x3f67
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x28(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::CopyTo(TiXmlElement*) const
void TiXmlElement::CopyTo( TiXmlElement* target ) const
{
	// superclass:
	TiXmlNode::CopyTo( target );

	// Element class: 
	// Clone the attributes, then clone the children.
	const TiXmlAttribute* attribute = 0;
	for(	attribute = attributeSet.First();
	attribute;
	attribute = attribute->Next() )
	{
		target->SetAttribute( attribute->Name(), attribute->Value() );
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %r15
addq $0x10, %r15
leaq 0x38(%rsi), %r12
movq %r15, %rdi
callq 0x30a0
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x890e
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
leaq 0x50(%r14), %rax
movq 0x88(%r14), %r15
cmpq %rax, %r15
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x41b3
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq $0x10, %rsi
addq $0x10, %rdx
movq %rbx, %rdi
callq 0x4832
movq 0x38(%r15), %r15
movq 0x28(%r15), %rax
cmpq $0x0, (%rax)
jne 0x4183
movq 0x20(%r15), %rax
cmpq $0x0, (%rax)
jne 0x4183
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x41d9
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36ac
movq 0x48(%r14), %r14
jmp 0x41b7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::ClearThis()
void TiXmlElement::ClearThis()
{
	Clear();
	while( attributeSet.First() )
	{
		TiXmlAttribute* node = attributeSet.First();
		attributeSet.Remove( node );
		delete node;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x4233
movq (%rdi), %rax
movq 0x48(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0x4221
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
leaq 0x50(%rbx), %r14
movq 0x88(%rbx), %r15
cmpq %r14, %r15
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x427a
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e2c
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq 0x88(%rbx), %r15
cmpq %r14, %r15
je 0x427a
testq %r15, %r15
jne 0x4255
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
addq $0x50, %r15
xorl %ebx, %ebx
movq %r15, %r12
movq 0x38(%r12), %r12
cmpq %r15, %r12
je 0x4305
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x42dd
movq 0x28(%r12), %rbx
addq $0x10, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
addq $0x50, %r12
xorl %ebx, %ebx
movq %r12, %r13
movq 0x38(%r13), %r13
cmpq %r12, %r13
je 0x436d
movq 0x20(%r13), %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x432f
movq 0x28(%r13), %rbx
addq $0x10, %rbx
testq %r14, %r14
je 0x436d
leaq 0x5ffd(%rip), %rsi      # 0xa35d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3110
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
addq $0x50, %r12
xorl %ebx, %ebx
movq %r12, %r13
movq 0x38(%r13), %r13
cmpq %r12, %r13
je 0x43fb
movq 0x20(%r13), %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x43bd
movq 0x28(%r13), %rbx
addq $0x10, %rbx
testq %r14, %r14
je 0x43fb
leaq 0x5f72(%rip), %rsi      # 0xa360
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3110
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x50, %r15
movq %r15, %r12
movq 0x38(%r12), %r12
cmpq %r15, %r12
je 0x448f
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x4448
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5ee6(%rip), %rsi      # 0xa35d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3110
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
setne %al
addl %eax, %eax
jmp 0x4494
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x50, %r15
movq %r15, %r12
movq 0x38(%r12), %r12
cmpq %r15, %r12
je 0x4510
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x44b8
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5e6a(%rip), %rsi      # 0xa35d
movq %r14, %rdx
xorl %eax, %eax
callq 0x3110
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
setne %al
addl %eax, %eax
movl (%r14), %ecx
movl %ecx, (%rbx)
jmp 0x4515
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x50, %r15
movq %r15, %r12
movq 0x38(%r12), %r12
cmpq %r15, %r12
je 0x463c
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x453a
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5ce8(%rip), %rsi      # 0xa255
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x70e8
movb $0x1, %bpl
testb %al, %al
jne 0x4635
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5cc6(%rip), %rsi      # 0xa25a
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x70e8
testb %al, %al
jne 0x4635
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x60e6(%rip), %rsi      # 0xa69e
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x70e8
testb %al, %al
jne 0x4635
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5c86(%rip), %rsi      # 0xa25e
xorl %ebp, %ebp
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x70e8
testb %al, %al
jne 0x4635
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5c6a(%rip), %rsi      # 0xa264
xorl %ebp, %ebp
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x70e8
testb %al, %al
jne 0x4635
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5b5d(%rip), %rsi      # 0xa179
xorl %ebp, %ebp
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x70e8
movl %eax, %ecx
movl $0x2, %eax
testb %cl, %cl
je 0x4641
movb %bpl, (%rbx)
xorl %eax, %eax
jmp 0x4641
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x50, %r15
movq %r15, %r12
movq 0x38(%r12), %r12
cmpq %r15, %r12
je 0x46a9
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x4662
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5ccf(%rip), %rsi      # 0xa360
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3110
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
setne %al
addl %eax, %eax
jmp 0x46ae
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rdi, %r14
movq 0x38(%r14), %r14
cmpq %r15, %r14
je 0x4708
movq 0x20(%r14), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x46e9
jmp 0x476b
movl $0x40, %edi
callq 0x3130
movq %rax, %r14
movq $-0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
leaq 0xb535(%rip), %rax      # 0xfc60
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x20(%r14), %r12
leaq 0xbb1b(%rip), %rax      # 0x10258
movq %rax, 0x20(%r14)
movq %rax, 0x28(%r14)
movups %xmm0, 0x30(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5ff6
movq %rbx, %rdi
callq 0x30a0
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x890e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x38(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq $0x0, (%rcx)
je 0x4a5b
retq
movq 0x20(%rax), %rcx
cmpq $0x0, (%rcx)
jne 0x4a5a
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rdi), %rax
movq 0x88(%rdi), %rcx
xorl %edx, %edx
cmpq %rax, %rcx
cmovneq %rcx, %rdx
movq (%rsi), %rax
movq %rsi, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq 0x28(%rbx), %r15
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4ac0
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x88(%rax)
testb %al, %al
je 0x4ac0
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0x4aa4
movq (%r14), %rax
movq 0x28(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x90, %edi
callq 0x3130
movq %rax, %rbx
movq 0x38(%r14), %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x3fd6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4128
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x90, %esi
movq %rbx, %rdi
callq 0x3140
movq %r14, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq $-0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
leaq 0x38(%rdi), %r12
leaq 0xb62e(%rip), %rax      # 0x10258
movq %rax, 0x38(%rdi)
movl $0x0, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x40(%rdi)
leaq 0xb064(%rip), %rcx      # 0xfca8
addq $0x10, %rcx
movq %rcx, (%rdi)
leaq 0x58(%rdi), %r14
movq %rax, 0x58(%rdi)
movl $0xffffffff, 0x68(%rdi) # imm = 0xFFFFFFFF
movabsq $-0xfffffffc, %rax      # imm = 0xFFFFFFFF00000004
movq %rax, 0x60(%rdi)
movb $0x0, 0x6c(%rdi)
movq %rsi, %rdi
callq 0x30a0
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x890e
movb $0x0, 0x50(%rbx)
movl $0x0, 0x54(%rbx)
leaq 0x5751(%rip), %rsi      # 0xa3e5
movq %r14, %rdi
xorl %edx, %edx
callq 0x890e
movq $0x0, 0x64(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r14), %rdi
cmpq 0xb321(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x4cd1
callq 0x31d0
movq %rbx, %rdi
callq 0x6750
movq %r15, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %r15
addq $0x10, %r15
leaq 0x38(%rsi), %r12
movq %r15, %rdi
callq 0x30a0
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x890e
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movb 0x50(%r14), %al
movb %al, 0x50(%rbx)
movl 0x54(%r14), %eax
movl %eax, 0x54(%rbx)
leaq 0x58(%rbx), %rdi
movq 0x58(%r14), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
callq 0x890e
movl 0x60(%r14), %eax
movl %eax, 0x60(%rbx)
movq 0x64(%r14), %rax
movq %rax, 0x64(%rbx)
movb 0x6c(%r14), %al
movb %al, 0x6c(%rbx)
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x4e0c
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36ac
movq 0x48(%r14), %r14
jmp 0x4dea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x67b0
leaq 0x38(%rbx), %r14
movq (%r15), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %r14, %rdi
callq 0x890e
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x5403(%rip), %rsi      # 0xa2b4
callq 0x3190
testq %rax, %rax
je 0x4ed8
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x4f98
movl %eax, %r14d
movq %r15, %rdi
callq 0x3120
jmp 0x4eef
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x768c
movq (%rsp), %rdi
cmpq 0xb0e6(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x4f0c
callq 0x31d0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f1e
jmp 0x4f1e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq 0xb0b4(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x4f3e
callq 0x31d0
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x56cb(%rip), %rsi      # 0xa630
movq %rax, %rdi
callq 0x3190
testq %rax, %rax
je 0x4f8e
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5180
movl %eax, %ebx
movq %r14, %rdi
callq 0x3120
movl %ebx, %eax
jmp 0x4f90
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x5266
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x5260
movl %edx, %ebx
movq %rsi, %r14
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq *0x10(%rax)
movl $0xa, %edi
movq %r14, %rsi
callq 0x31c0
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0x523c
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4ffa(%rip), %rdi      # 0xa267
leaq 0x4dc3(%rip), %rsi      # 0xa037
leaq 0x509a(%rip), %rcx      # 0xa315
movl $0x47b, %edx            # imm = 0x47B
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq 0x28(%rbx), %r15
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x52ca
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x88(%rax)
testb %al, %al
je 0x52ca
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0x52ae
movq (%r14), %rax
movq 0x18(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x30(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq $0x0, (%rcx)
je 0x52ed
retq
movq 0x20(%rax), %rcx
cmpq $0x0, (%rcx)
jne 0x52ec
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xaf45(%rip), %rax      # 0x10258
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rax, (%rsp)
addq $0x20, %rdi
callq 0x3432
addq $0x28, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x3432
movq (%r15), %rax
cmpq $0x0, (%rax)
je 0x536b
movb 0x10(%rax), %dl
testb %dl, %dl
je 0x536b
xorl %ecx, %ecx
cmpb $0x22, %dl
je 0x535b
movb 0x11(%rax,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x5349
jmp 0x536b
leaq 0x5b3e(%rip), %rax      # 0xaea0
cmpq %rcx, (%rax)
jne 0x542b
testq %r14, %r14
je 0x5392
movq 0x8(%rsp), %rdx
addq $0x10, %rdx
movq (%rsp), %rcx
addq $0x10, %rcx
leaq 0x4fc2(%rip), %rsi      # 0xa34a
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x53e6
movq 0x8(%rsp), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x89c2
leaq 0x5088(%rip), %rsi      # 0xa43a
movl $0x2, %edx
movq %rbx, %rdi
callq 0x89c2
movq (%rsp), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x89c2
leaq 0x5062(%rip), %rsi      # 0xa43b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x89c2
movq (%rsp), %rdi
cmpq 0xabef(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x5403
callq 0x31d0
movq 0x8(%rsp), %rdi
cmpq 0xabd1(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x5421
callq 0x31d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
testq %r14, %r14
je 0x5452
movq 0x8(%rsp), %rdx
addq $0x10, %rdx
movq (%rsp), %rcx
addq $0x10, %rcx
leaq 0x4f0a(%rip), %rsi      # 0xa352
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x53e6
movq 0x8(%rsp), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x89c2
leaq 0x4ee8(%rip), %rsi      # 0xa35a
movl $0x2, %edx
movq %rbx, %rdi
callq 0x89c2
movq (%rsp), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x89c2
leaq 0x4ec2(%rip), %rsi      # 0xa35b
jmp 0x53d9
movq %rax, %rbx
movq (%rsp), %rdi
cmpq 0xab34(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x54be
callq 0x31d0
movq 0x8(%rsp), %rdi
cmpq 0xab16(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x54dc
callq 0x31d0
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x56af
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
jle 0x568c
leaq 0x4c2e(%rip), %r15      # 0xa2a1
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x32a0
decl %ebp
jne 0x5673
movq 0x38(%r14), %rdx
addq $0x10, %rdx
leaq 0x4d00(%rip), %rsi      # 0xa39b
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
leaq 0x4bb1(%rip), %rdi      # 0xa267
leaq 0x497a(%rip), %rsi      # 0xa037
leaq 0x4ca3(%rip), %rcx      # 0xa367
movl $0x513, %edx            # imm = 0x513
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x50, %edi
callq 0x3130
movq %rax, %r14
movq $-0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
leaq 0x38(%rax), %r15
leaq 0xab46(%rip), %rax      # 0x10258
movq %rax, 0x38(%r14)
movl $0x2, 0x20(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x40(%r14)
leaq 0xa191(%rip), %rax      # 0xf8c0
movq %rax, (%r14)
movq 0x38(%rbx), %r12
addq $0x10, %r12
movq %r12, %rdi
callq 0x30a0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x890e
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x5833
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x50(%rdi)
jne 0x57e2
movl %edx, %ebp
movl $0xa, %edi
movq %rbx, %rsi
callq 0x31c0
testl %ebp, %ebp
jle 0x57bf
leaq 0x4afb(%rip), %r15      # 0xa2a1
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x32a0
decl %ebp
jne 0x57a6
movq 0x38(%r14), %rdx
addq $0x10, %rdx
leaq 0x4c08(%rip), %rsi      # 0xa3d6
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
leaq 0xaa6f(%rip), %rax      # 0x10258
movq %rsp, %rsi
movq %rax, (%rsi)
addq $0x38, %r14
movq %r14, %rdi
callq 0x3432
movq (%rsp), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x3180
movq (%rsp), %rdi
cmpq 0xa7ca(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x5828
callq 0x31d0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4a2d(%rip), %rdi      # 0xa267
leaq 0x47f6(%rip), %rsi      # 0xa037
leaq 0x4b5d(%rip), %rcx      # 0xa3a5
movl $0x536, %edx            # imm = 0x536
callq 0x30e0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq 0xa780(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x5872
callq 0x31d0
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %r15
addq $0x10, %r15
leaq 0x38(%rsi), %r12
movq %r15, %rdi
callq 0x30a0
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x890e
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
leaq 0x50(%rbx), %rdi
movq 0x50(%r14), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
callq 0x890e
leaq 0x58(%rbx), %rdi
movq 0x58(%r14), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
callq 0x890e
addq $0x60, %rbx
movq 0x60(%r14), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x890e
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDeclaration::Print(_IO_FILE*, int, TiXmlString*) const
void TiXmlDeclaration::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const
{
	if ( cfile ) fprintf( cfile, "<?xml " );
	if ( str )	 (*str) += "<?xml ";

	if ( !version.empty() ) {
		if ( cfile ) fprintf (cfile, "version=\"%s\" ", version.c_str ());
		if ( str ) { (*str) += "version=\""; (*str) += version; (*str) += "\" "; }
	}
	if ( !encoding.empty() ) {
		if ( cfile ) fprintf (cfile, "encoding=\"%s\" ", encoding.c_str ());
		if ( str ) { (*str) += "encoding=\""; (*str) += encoding; (*str) += "\" "; }
	}
	if ( !standalone.empty() ) {
		if ( cfile ) fprintf (cfile, "standalone=\"%s\" ", standalone.c_str ());
		if ( str ) { (*str) += "standalone=\""; (*str) += standalone; (*str) += "\" "; }
	}
	if ( cfile ) fprintf( cfile, "?>" );
	if ( str )	 (*str) += "?>";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x5bdc
leaq 0x481c(%rip), %rdi      # 0xa3e6
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x32a0
testq %rbx, %rbx
je 0x5bf5
leaq 0x47fe(%rip), %rsi      # 0xa3e6
movl $0x6, %edx
movq %rbx, %rdi
callq 0x89c2
movq 0x50(%r15), %rdx
cmpq $0x0, (%rdx)
je 0x5c59
testq %r14, %r14
je 0x5c19
addq $0x10, %rdx
leaq 0x47de(%rip), %rsi      # 0xa3ed
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x5c59
leaq 0x47d6(%rip), %rsi      # 0xa3fb
movl $0x9, %edx
movq %rbx, %rdi
callq 0x89c2
movq 0x50(%r15), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x89c2
leaq 0x47e1(%rip), %rsi      # 0xa42d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x89c2
movq 0x58(%r15), %rdx
cmpq $0x0, (%rdx)
je 0x5cbd
testq %r14, %r14
je 0x5c7d
addq $0x10, %rdx
leaq 0x4792(%rip), %rsi      # 0xa405
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x5cbd
leaq 0x478b(%rip), %rsi      # 0xa414
movl $0xa, %edx
movq %rbx, %rdi
callq 0x89c2
movq 0x58(%r15), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x89c2
leaq 0x477d(%rip), %rsi      # 0xa42d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x89c2
movq 0x60(%r15), %rdx
cmpq $0x0, (%rdx)
je 0x5d21
testq %r14, %r14
je 0x5ce1
addq $0x10, %rdx
leaq 0x4748(%rip), %rsi      # 0xa41f
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x5d21
leaq 0x4743(%rip), %rsi      # 0xa430
movl $0xc, %edx
movq %rbx, %rdi
callq 0x89c2
movq 0x60(%r15), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x89c2
leaq 0x4719(%rip), %rsi      # 0xa42d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x89c2
testq %r14, %r14
je 0x5d3f
leaq 0x4710(%rip), %rdi      # 0xa43d
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x32a0
testq %rbx, %rbx
je 0x5d5d
leaq 0x46f2(%rip), %rsi      # 0xa43d
movl $0x2, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x89c2
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x68, %edi
callq 0x3130
movq %rax, %r14
movq $-0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
leaq 0xa4b8(%rip), %rax      # 0x10258
movq %rax, 0x38(%r14)
movl $0x5, 0x20(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x40(%r14)
leaq 0x9ba3(%rip), %rcx      # 0xf960
movq %rcx, (%r14)
movq %rax, 0x50(%r14)
movq %rax, 0x58(%r14)
movq %rax, 0x60(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ad8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x50, %edi
callq 0x3130
movq %rax, %r14
movq $-0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
leaq 0x38(%rax), %r15
leaq 0xa390(%rip), %rax      # 0x10258
movq %rax, 0x38(%r14)
movl $0x3, 0x20(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x40(%r14)
leaq 0x9c23(%rip), %rax      # 0xfb08
movq %rax, (%r14)
movq 0x38(%rbx), %r12
addq $0x10, %r12
movq %r12, %rdi
callq 0x30a0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x890e
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %r15
addq $0x10, %r15
movq %rdi, %r12
movq 0x38(%r12), %r12
cmpq %r14, %r12
je 0x604d
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x600f
leaq 0x446e(%rip), %rdi      # 0xa4a3
leaq 0x3ffb(%rip), %rsi      # 0xa037
leaq 0x4477(%rip), %rcx      # 0xa4ba
movl $0x5ef, %edx            # imm = 0x5EF
callq 0x30e0
movq %r14, 0x38(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq %rbx, 0x38(%rax)
movq %rbx, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdi, %rax
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x6082
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
jne 0x6084
xorl %ecx, %ecx
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x60c1
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x60c1
movq %rdx, %r14
movq 0x38(%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x60c4
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0x60a4
xorl %r15d, %r15d
movq %r15, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x610a
movq 0x28(%rax), %r14
testq %r14, %r14
je 0x610a
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testq %rax, %rax
jne 0x60fc
movq 0x48(%r14), %r14
jmp 0x60e3
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testq %rax, %rax
jne 0x610c
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x6133
movq %rdx, %rsi
callq 0x3ea2
testq %rax, %rax
jne 0x6135
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdi, %rax
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x6185
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
setne %sil
sete %dil
testl %edx, %edx
setle %r8b
orb %dil, %r8b
jne 0x6180
movl $0x1, %edi
movq 0x48(%rcx), %rcx
testq %rcx, %rcx
setne %sil
je 0x6180
leal 0x1(%rdi), %r8d
cmpl %edx, %edi
movl %r8d, %edi
jl 0x6168
testb %sil, %sil
jne 0x6187
xorl %ecx, %ecx
movq %rcx, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x61ca
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x61ca
movl %ecx, %ebp
movq %rdx, %r14
movq 0x38(%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x61dc
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0x61ad
xorl %r15d, %r15d
movq %r15, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
jle 0x61cd
xorl %r12d, %r12d
movq 0x48(%r15), %r15
testq %r15, %r15
je 0x61ca
movq 0x38(%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x61e3
incl %r12d
cmpl %ebp, %r12d
jl 0x61e3
jmp 0x61cd
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x6298
movq 0x28(%rax), %r14
testq %r14, %r14
je 0x6298
movl %edx, %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testq %rax, %rax
jne 0x6240
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0x6227
jmp 0x6298
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movq %rax, %r14
testq %rax, %rax
setne %al
sete %cl
testl %ebp, %ebp
setle %dl
orb %cl, %dl
jne 0x6294
xorl %r15d, %r15d
movq 0x48(%r14), %r14
testq %r14, %r14
je 0x6298
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testq %rax, %rax
je 0x6261
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movq %rax, %r14
testq %rax, %rax
setne %al
je 0x6294
incl %r15d
cmpl %ebp, %r15d
jl 0x6261
testb %al, %al
jne 0x629b
xorl %r14d, %r14d
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x6308
movl %ecx, %ebp
movq %rdx, %r14
movq %rdx, %rsi
callq 0x3ea2
testq %rax, %rax
setne %cl
sete %dl
testl %ebp, %ebp
setle %sil
orb %dl, %sil
jne 0x6304
movl $0x1, %r15d
movq %rax, %rdi
movq %r14, %rsi
callq 0x3f3e
testq %rax, %rax
setne %cl
je 0x6304
leal 0x1(%r15), %edx
cmpl %ebp, %r15d
movl %edx, %r15d
jl 0x62e5
testb %cl, %cl
jne 0x630a
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x6888
leaq 0x10(%rbx), %r14
leaq 0x41d3(%rip), %rsi      # 0xa519
movl $0x1, %edx
movq %r14, %rdi
callq 0x89c2
movq 0x38(%r15), %r13
addq $0x10, %r13
movq %r13, %rdi
callq 0x30a0
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x89c2
testq %r12, %r12
je 0x63b5
leaq 0x3f27(%rip), %r13      # 0xa2a4
movl $0x1, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x89c2
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x52fa
movq 0x38(%r12), %r12
movq 0x28(%r12), %rax
cmpq $0x0, (%rax)
jne 0x637d
movq 0x20(%r12), %rax
cmpq $0x0, (%rax)
jne 0x637d
cmpq $0x0, 0x28(%r15)
je 0x63fb
leaq 0x3fe0(%rip), %rsi      # 0xa3a3
movl $0x1, %edx
movq %r14, %rdi
callq 0x89c2
movq 0x28(%r15), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
je 0x640f
movq 0x28(%r15), %rdi
cmpq %rdi, 0x30(%r15)
jne 0x640f
movq (%rdi), %rax
callq *0x40(%rax)
cmpb $0x0, 0x50(%rax)
jne 0x640f
movb $0x1, 0xc(%rbx)
jmp 0x6422
leaq 0x3ea8(%rip), %rsi      # 0xa2aa
movl $0x3, %edx
movq %r14, %rdi
callq 0x89c2
movq 0x20(%rbx), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %r14, %rdi
callq 0x89c2
incl 0x8(%rbx)
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
decl 0x8(%rdi)
cmpq $0x0, 0x28(%rsi)
je 0x64c1
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, %r15
cmpb $0x1, 0xc(%rdi)
jne 0x6457
movb $0x0, 0xc(%rbx)
jmp 0x645f
movq %rbx, %rdi
callq 0x6888
leaq 0x10(%rbx), %r14
leaq 0x40b1(%rip), %rsi      # 0xa51b
movl $0x2, %edx
movq %r14, %rdi
callq 0x89c2
movq 0x38(%r15), %r15
addq $0x10, %r15
movq %r15, %rdi
callq 0x30a0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x89c2
leaq 0x3f07(%rip), %rsi      # 0xa3a3
movl $0x1, %edx
movq %r14, %rdi
callq 0x89c2
movq 0x20(%rbx), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %r14, %rdi
callq 0x89c2
popq %rbx
popq %r14
popq %r15
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlPrinter::Visit(TiXmlText const&)
bool TiXmlPrinter::Visit( const TiXmlText& text )
{
	if ( text.CDATA() )
	{
		DoIndent();
		buffer += "<![CDATA[";
		buffer += text.Value();
		buffer += "]]>";
		DoLineBreak();
	}
	else if ( simpleTextPrint )
	{
		TIXML_STRING str;
		TiXmlBase::EncodeString( text.ValueTStr(), &str );
		buffer += str;
	}
	else
	{
		DoIndent();
		TIXML_STRING str;
		TiXmlBase::EncodeString( text.ValueTStr(), &str );
		buffer += str;
		DoLineBreak();
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x50(%rsi)
jne 0x6543
movq %rbx, %rdi
callq 0x6888
leaq 0x10(%rbx), %r15
leaq 0x4032(%rip), %rsi      # 0xa51e
movl $0x9, %edx
movq %r15, %rdi
callq 0x89c2
movq 0x38(%r14), %r14
addq $0x10, %r14
movq %r14, %rdi
callq 0x30a0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x89c2
leaq 0x400a(%rip), %rsi      # 0xa528
movl $0x3, %edx
movq %r15, %rdi
callq 0x89c2
movq 0x20(%rbx), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %r15, %rdi
callq 0x89c2
jmp 0x65ea
cmpb $0x1, 0xc(%rbx)
jne 0x657e
leaq 0x9d08(%rip), %rax      # 0x10258
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
addq $0x38, %r14
movq %r14, %rdi
callq 0x3432
addq $0x10, %rbx
movq 0x8(%rsp), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x89c2
jmp 0x65cc
movq %rbx, %rdi
callq 0x6888
leaq 0x9ccb(%rip), %rax      # 0x10258
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
addq $0x38, %r14
movq %r14, %rdi
callq 0x3432
leaq 0x10(%rbx), %r14
movq 0x8(%rsp), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %r14, %rdi
callq 0x89c2
movq 0x20(%rbx), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %r14, %rdi
callq 0x89c2
movq 0x8(%rsp), %rdi
cmpq 0x9a08(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x65ea
callq 0x31d0
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x65f8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq 0x99d9(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x6619
callq 0x31d0
movq %rbx, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlPrinter::Visit(TiXmlDeclaration const&)
bool TiXmlPrinter::Visit( const TiXmlDeclaration& declaration )
{
	DoIndent();
	declaration.Print( 0, 0, &buffer );
	DoLineBreak();
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6888
leaq 0x10(%r14), %r15
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq *0x90(%rax)
movq 0x20(%r14), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %r15, %rdi
callq 0x89c2
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq