LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::IterateChildren(char const*, TiXmlNode const*) const
const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const
{
	if ( !previous )
	{
		return FirstChild( val );
	}
	else
	{
		assert( previous->parent == this );
		return previous->NextSibling( val );
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdx, %rdx
je 0x3cfe
movq %rdx, %rbx
cmpq %rdi, 0x18(%rdx)
jne 0x3d2e
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
je 0x3d21
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x3cdf
jmp 0x3d23
movq 0x28(%rdi), %rbx
testq %rbx, %rbx
je 0x3d21
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x3d23
movq 0x48(%rbx), %rbx
jmp 0x3d02
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x646f(%rip), %rdi      # 0xa1a4
leaq 0x62fb(%rip), %rsi      # 0xa037
leaq 0x64bf(%rip), %rcx      # 0xa202
movl $0x197, %edx            # imm = 0x197
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::RemoveAttribute(char const*)
void TiXmlElement::RemoveAttribute( const char * name )
{
    #ifdef TIXML_USE_STL
	TIXML_STRING str( name );
	TiXmlAttribute* node = attributeSet.Find( str );
	#else
	TiXmlAttribute* node = attributeSet.Find( name );
	#endif
	if ( node )
	{
		attributeSet.Remove( node );
		delete node;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
addq $0x50, %rbx
movq %rbx, %r14
movq 0x38(%r14), %r14
cmpq %rbx, %r14
je 0x3deb
movq 0x20(%r14), %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x3dcc
jmp 0x3dee
xorl %r14d, %r14d
testq %r14, %r14
je 0x3e0c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e4a
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttributeSet::Remove(TiXmlAttribute*)
void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe )
{
	TiXmlAttribute* node;

	for( node = sentinel.next; node != &sentinel; node = node->next )
	{
		if ( node == removeMe )
		{
			node->prev->next = node->next;
			node->next->prev = node->prev;
			node->next = 0;
			node->prev = 0;
			return;
		}
	}
	assert( 0 );		// we tried to remove a non-linked attribute.
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq 0x38(%rax), %rax
cmpq %rdi, %rax
je 0x3e79
cmpq %rsi, %rax
jne 0x3e4e
movq 0x30(%rax), %rcx
movq 0x38(%rax), %rdx
movq %rdx, 0x38(%rcx)
movq 0x38(%rax), %rdx
movq %rcx, 0x30(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
popq %rax
retq
leaq 0x62f9(%rip), %rdi      # 0xa179
leaq 0x61b0(%rip), %rsi      # 0xa037
leaq 0x665a(%rip), %rcx      # 0xa4e8
movl $0x608, %edx            # imm = 0x608
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O1/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::FirstChildElement() const
const TiXmlElement* TiXmlNode::FirstChildElement() const
{
	const TiXmlNode* node;

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

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rbx
testq %rbx, %rbx
je 0x3eb6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testq %rax, %rax
jne 0x3eba
movq 0x48(%rbx), %rbx
jmp 0x3e9d
xorl %eax, %eax
popq %rbx
retq
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x28(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::FirstChildElement(char const*) const
const TiXmlElement* TiXmlNode::FirstChildElement( const char * _value ) const
{
	const TiXmlNode* node;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x3eee
movq 0x38(%r14), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x31e0
testl %eax, %eax
je 0x3ef1
movq 0x48(%r14), %r14
jmp 0x3ecf
xorl %r14d, %r14d
testq %r14, %r14
je 0x3f23
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testq %rax, %rax
jne 0x3f2d
movq 0x48(%r14), %r14
testq %r14, %r14
je 0x3eee
movq 0x38(%r14), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x3f04
jmp 0x3ef1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x28(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::NextSiblingElement() const
const TiXmlElement* TiXmlNode::NextSiblingElement() const
{
	const TiXmlNode* node;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
je 0x3f63
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testq %rax, %rax
je 0x3f42
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x28(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
movq 0x48(%r14), %r14
testq %r14, %r14
je 0x3f91
movq 0x38(%r14), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x3f72
jmp 0x3f94
xorl %r14d, %r14d
testq %r14, %r14
je 0x3fc6
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testq %rax, %rax
jne 0x3fd0
movq 0x48(%r14), %r14
testq %r14, %r14
je 0x3f91
movq 0x38(%r14), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x3fa7
jmp 0x3f94
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x28(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ae8
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 0x41fd
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq $0x10, %rsi
addq $0x10, %rdx
movq %rbx, %rdi
callq 0x48c2
movq 0x38(%r15), %r15
movq 0x28(%r15), %rax
cmpq $0x0, (%rax)
jne 0x41f8
movq 0x20(%r15), %rax
cmpq $0x0, (%rax)
jne 0x41f8
xorl %r15d, %r15d
testq %r15, %r15
jne 0x41c5
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x4223
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x369c
movq 0x48(%r14), %r14
jmp 0x4201
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x427d
movq (%rdi), %rax
movq 0x48(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0x426b
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 0x42c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e4a
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq 0x88(%rbx), %r15
cmpq %r14, %r15
je 0x42c4
testq %r15, %r15
jne 0x429f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x50, %r14
movq %r14, %r15
movq 0x38(%r15), %r15
cmpq %r14, %r15
je 0x4341
movq 0x20(%r15), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x4322
jmp 0x4344
xorl %r15d, %r15d
testq %r15, %r15
je 0x4353
movq 0x28(%r15), %rax
addq $0x10, %rax
jmp 0x4355
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %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 0x4395
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x4374
jmp 0x4398
xorl %r12d, %r12d
testq %r12, %r12
je 0x43c1
movq 0x28(%r12), %r14
addq $0x10, %r14
testq %rbx, %rbx
je 0x43c4
leaq 0x5fab(%rip), %rsi      # 0xa35d
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3110
jmp 0x43c4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %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 0x4435
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x4414
jmp 0x4438
xorl %r12d, %r12d
testq %r12, %r12
je 0x4461
movq 0x28(%r12), %r14
addq $0x10, %r14
testq %rbx, %rbx
je 0x4464
leaq 0x5f0e(%rip), %rsi      # 0xa360
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3110
jmp 0x4464
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x44d5
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x44b4
jmp 0x44d8
xorl %r12d, %r12d
testq %r12, %r12
je 0x4505
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5e70(%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 0x450a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x454f
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x452e
jmp 0x4552
xorl %r12d, %r12d
testq %r12, %r12
je 0x4590
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5dea(%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 0x4595
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45db
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x45ba
jmp 0x45de
xorl %r12d, %r12d
testq %r12, %r12
je 0x46c6
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5c5e(%rip), %rsi      # 0xa255
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7254
movb $0x1, %bpl
testb %al, %al
jne 0x46bf
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5c3c(%rip), %rsi      # 0xa25a
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7254
testb %al, %al
jne 0x46bf
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x649c(%rip), %rsi      # 0xaade
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7254
testb %al, %al
jne 0x46bf
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5bfc(%rip), %rsi      # 0xa25e
xorl %ebp, %ebp
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7254
testb %al, %al
jne 0x46bf
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5be0(%rip), %rsi      # 0xa264
xorl %ebp, %ebp
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7254
testb %al, %al
jne 0x46bf
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5ad3(%rip), %rsi      # 0xa179
xorl %ebp, %ebp
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7254
movl %eax, %ecx
movl $0x2, %eax
testb %cl, %cl
je 0x46cb
movb %bpl, (%rbx)
xorl %eax, %eax
jmp 0x46cb
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x470d
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x46ec
jmp 0x4710
xorl %r12d, %r12d
testq %r12, %r12
je 0x473d
movq 0x28(%r12), %rdi
addq $0x10, %rdi
leaq 0x5c3b(%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 0x4742
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4796
movq 0x20(%r14), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x4777
jmp 0x4799
xorl %r14d, %r14d
testq %r14, %r14
jne 0x4801
movl $0x40, %edi
callq 0x3130
movq %rax, %r14
movq $-0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
leaq 0xb49f(%rip), %rax      # 0xfc60
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x20(%r14), %r12
leaq 0xba85(%rip), %rax      # 0x10258
movq %rax, 0x20(%r14)
movq %rax, 0x28(%r14)
movups %xmm0, 0x30(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x60b0
movq %rbx, %rdi
callq 0x30a0
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x8ae8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ae3
retq
movq 0x20(%rax), %rcx
cmpq $0x0, (%rcx)
jne 0x4ae2
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b48
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x88(%rax)
testb %al, %al
je 0x4b48
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0x4b2c
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_O1/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 0x400a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x416a
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_O1/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 0xb5a0(%rip), %rax      # 0x10258
movq %rax, 0x38(%rdi)
movl $0x0, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x40(%rdi)
leaq 0xafd6(%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 0x8ae8
movb $0x0, 0x50(%rbx)
movl $0x0, 0x54(%rbx)
leaq 0x56c3(%rip), %rsi      # 0xa3e5
movq %r14, %rdi
xorl %edx, %edx
callq 0x8ae8
movq $0x0, 0x64(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r14), %rdi
cmpq 0xb293(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x4d5f
callq 0x31d0
movq %rbx, %rdi
callq 0x6850
movq %r15, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ae8
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 0x8ae8
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 0x4e9a
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x369c
movq 0x48(%r14), %r14
jmp 0x4e78
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68b0
leaq 0x38(%rbx), %r14
movq (%r15), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %r14, %rdi
callq 0x8ae8
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x5375(%rip), %rsi      # 0xa2b4
callq 0x3190
testq %rax, %rax
je 0x4f66
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x5026
movl %eax, %r14d
movq %r15, %rdi
callq 0x3120
jmp 0x4f7d
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x77f6
movq (%rsp), %rdi
cmpq 0xb058(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x4f9a
callq 0x31d0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4fac
jmp 0x4fac
movq %rax, %rbx
movq (%rsp), %rdi
cmpq 0xb026(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x4fcc
callq 0x31d0
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a7d(%rip), %rsi      # 0xaa70
movq %rax, %rdi
callq 0x3190
testq %rax, %rax
je 0x501c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x520e
movl %eax, %ebx
movq %r14, %rdi
callq 0x3120
movl %ebx, %eax
jmp 0x501e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x6c(%rdi)
jne 0x5245
movl $0xef, %edi
movq %rbx, %rsi
callq 0x31c0
movl $0xbb, %edi
movq %rbx, %rsi
callq 0x31c0
movl $0xbf, %edi
movq %rbx, %rsi
callq 0x31c0
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *0x10(%rax)
movq %rbx, %rdi
callq 0x3290
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52f4
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x52ee
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 0x52ca
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4f6c(%rip), %rdi      # 0xa267
leaq 0x4d35(%rip), %rsi      # 0xa037
leaq 0x500c(%rip), %rcx      # 0xa315
movl $0x47b, %edx            # imm = 0x47B
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5358
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x88(%rax)
testb %al, %al
je 0x5358
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0x533c
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_O1/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 0x537b
retq
movq 0x20(%rax), %rcx
cmpq $0x0, (%rcx)
jne 0x537a
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaeb7(%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), %rcx
cmpq $0x0, (%rcx)
je 0x540a
movb 0x10(%rcx), %sil
testb %sil, %sil
sete %dl
je 0x5406
addq $0x10, %rcx
movq %rcx, %rax
cmpb $0x22, %sil
je 0x53ff
movq %rcx, %rax
movb 0x1(%rax), %sil
testb %sil, %sil
sete %dl
je 0x5406
incq %rax
cmpb $0x22, %sil
jne 0x53ea
subq %rcx, %rax
xorl %edx, %edx
jmp 0x5406
testb %dl, %dl
je 0x5414
leaq 0x5aa7(%rip), %rax      # 0xaeb8
movq (%rax), %rax
leaq 0x5a9d(%rip), %rcx      # 0xaeb8
cmpq (%rcx), %rax
jne 0x5494
testq %r14, %r14
je 0x5447
movq 0x8(%rsp), %rdx
addq $0x10, %rdx
movq (%rsp), %rcx
addq $0x10, %rcx
leaq 0x4f0d(%rip), %rsi      # 0xa34a
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x550f
movq 0x8(%rsp), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x8b94
leaq 0x4fcf(%rip), %rsi      # 0xa43a
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8b94
movq (%rsp), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x8b94
leaq 0x4fa9(%rip), %rsi      # 0xa43b
jmp 0x5502
testq %r14, %r14
je 0x54bb
movq 0x8(%rsp), %rdx
addq $0x10, %rdx
movq (%rsp), %rcx
addq $0x10, %rcx
leaq 0x4ea1(%rip), %rsi      # 0xa352
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x550f
movq 0x8(%rsp), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x8b94
leaq 0x4e7f(%rip), %rsi      # 0xa35a
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8b94
movq (%rsp), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x8b94
leaq 0x4e59(%rip), %rsi      # 0xa35b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8b94
movq (%rsp), %rdi
cmpq 0xaac6(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x552c
callq 0x31d0
movq 0x8(%rsp), %rdi
cmpq 0xaaa8(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x554a
callq 0x31d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq 0xaa7e(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x5574
callq 0x31d0
movq 0x8(%rsp), %rdi
cmpq 0xaa60(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x5592
callq 0x31d0
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5765
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
jle 0x5742
leaq 0x4b78(%rip), %r15      # 0xa2a1
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x32a0
decl %ebp
jne 0x5729
movq 0x38(%r14), %rdx
addq $0x10, %rdx
leaq 0x4c4a(%rip), %rsi      # 0xa39b
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
leaq 0x4afb(%rip), %rdi      # 0xa267
leaq 0x48c4(%rip), %rsi      # 0xa037
leaq 0x4bed(%rip), %rcx      # 0xa367
movl $0x513, %edx            # imm = 0x513
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaa90(%rip), %rax      # 0x10258
movq %rax, 0x38(%r14)
movl $0x2, 0x20(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x40(%r14)
leaq 0xa0ab(%rip), %rax      # 0xf890
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 0x8ae8
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_O1/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 0x58e9
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x50(%rdi)
jne 0x5898
movl %edx, %ebp
movl $0xa, %edi
movq %rbx, %rsi
callq 0x31c0
testl %ebp, %ebp
jle 0x5875
leaq 0x4a45(%rip), %r15      # 0xa2a1
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x32a0
decl %ebp
jne 0x585c
movq 0x38(%r14), %rdx
addq $0x10, %rdx
leaq 0x4b52(%rip), %rsi      # 0xa3d6
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
leaq 0xa9b9(%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 0xa714(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x58de
callq 0x31d0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4977(%rip), %rdi      # 0xa267
leaq 0x4740(%rip), %rsi      # 0xa037
leaq 0x4aa7(%rip), %rcx      # 0xa3a5
movl $0x536, %edx            # imm = 0x536
callq 0x30e0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq 0xa6ca(%rip), %rdi      # 0xffe0
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x5928
callq 0x31d0
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ae8
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 0x8ae8
leaq 0x58(%rbx), %rdi
movq 0x58(%r14), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
callq 0x8ae8
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 0x8ae8
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c92
leaq 0x4766(%rip), %rdi      # 0xa3e6
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x32a0
testq %rbx, %rbx
je 0x5cab
leaq 0x4748(%rip), %rsi      # 0xa3e6
movl $0x6, %edx
movq %rbx, %rdi
callq 0x8b94
movq 0x50(%r15), %rdx
cmpq $0x0, (%rdx)
je 0x5d0f
testq %r14, %r14
je 0x5ccf
addq $0x10, %rdx
leaq 0x4728(%rip), %rsi      # 0xa3ed
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x5d0f
leaq 0x4720(%rip), %rsi      # 0xa3fb
movl $0x9, %edx
movq %rbx, %rdi
callq 0x8b94
movq 0x50(%r15), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x8b94
leaq 0x472b(%rip), %rsi      # 0xa42d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8b94
movq 0x58(%r15), %rdx
cmpq $0x0, (%rdx)
je 0x5d73
testq %r14, %r14
je 0x5d33
addq $0x10, %rdx
leaq 0x46dc(%rip), %rsi      # 0xa405
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x5d73
leaq 0x46d5(%rip), %rsi      # 0xa414
movl $0xa, %edx
movq %rbx, %rdi
callq 0x8b94
movq 0x58(%r15), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x8b94
leaq 0x46c7(%rip), %rsi      # 0xa42d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8b94
movq 0x60(%r15), %rdx
cmpq $0x0, (%rdx)
je 0x5dd7
testq %r14, %r14
je 0x5d97
addq $0x10, %rdx
leaq 0x4692(%rip), %rsi      # 0xa41f
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x5dd7
leaq 0x468d(%rip), %rsi      # 0xa430
movl $0xc, %edx
movq %rbx, %rdi
callq 0x8b94
movq 0x60(%r15), %rsi
movq (%rsi), %rdx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x8b94
leaq 0x4663(%rip), %rsi      # 0xa42d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8b94
testq %r14, %r14
je 0x5df5
leaq 0x465a(%rip), %rdi      # 0xa43d
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x32a0
testq %rbx, %rbx
je 0x5e13
leaq 0x463c(%rip), %rsi      # 0xa43d
movl $0x2, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8b94
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa402(%rip), %rax      # 0x10258
movq %rax, 0x38(%r14)
movl $0x5, 0x20(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x40(%r14)
leaq 0x9abd(%rip), %rcx      # 0xf930
movq %rcx, (%r14)
movq %rax, 0x50(%r14)
movq %rax, 0x58(%r14)
movq %rax, 0x60(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b8e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa2da(%rip), %rax      # 0x10258
movq %rax, 0x38(%r14)
movl $0x3, 0x20(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x40(%r14)
leaq 0x9b3d(%rip), %rax      # 0xfad8
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 0x8ae8
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_O1/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 0x60ea
movq 0x20(%r12), %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x60c9
jmp 0x60ed
xorl %r12d, %r12d
testq %r12, %r12
jne 0x6116
movq %r14, 0x38(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq 0x30(%r14), %rax
movq %rbx, 0x38(%rax)
movq %rbx, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4386(%rip), %rdi      # 0xa4a3
leaq 0x3f13(%rip), %rsi      # 0xa037
leaq 0x438f(%rip), %rcx      # 0xa4ba
movl $0x5ef, %edx            # imm = 0x5EF
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x614a
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
jne 0x614c
xorl %ecx, %ecx
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6191
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x6189
movq %rdx, %r14
movq 0x38(%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x618c
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0x616c
xorl %r15d, %r15d
testq %r15, %r15
jne 0x6194
xorl %r15d, %r15d
movq %r15, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x61e1
movq 0x28(%rax), %r15
xorl %r14d, %r14d
testq %r15, %r15
je 0x61dc
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
testq %rax, %rax
jne 0x61d0
movq 0x48(%r15), %r15
jmp 0x61b7
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movq %rax, %r14
testq %r14, %r14
jne 0x61e4
xorl %r14d, %r14d
movq %r14, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6209
movq %rdx, %rsi
callq 0x3ec4
testq %rax, %rax
jne 0x620b
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x625b
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
setne %sil
sete %dil
testl %edx, %edx
setle %r8b
orb %dil, %r8b
jne 0x6256
movl $0x1, %edi
movq 0x48(%rcx), %rcx
testq %rcx, %rcx
setne %sil
je 0x6256
leal 0x1(%rdi), %r8d
cmpl %edx, %edi
movl %r8d, %edi
jl 0x623e
testb %sil, %sil
jne 0x625d
xorl %ecx, %ecx
movq %rcx, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x62eb
movl %ecx, %ebp
movq %rdx, %r14
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x629d
movq 0x38(%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x62a0
movq 0x48(%r15), %r15
jmp 0x627e
xorl %r15d, %r15d
testq %r15, %r15
setne %al
sete %cl
testl %ebp, %ebp
setle %dl
orb %cl, %dl
jne 0x62e7
xorl %r12d, %r12d
movq 0x48(%r15), %r15
testq %r15, %r15
je 0x62d4
movq 0x38(%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x62b5
jmp 0x62d7
xorl %r15d, %r15d
testq %r15, %r15
setne %al
je 0x62e7
incl %r12d
cmpl %ebp, %r12d
jl 0x62b5
testb %al, %al
jne 0x62ee
xorl %r15d, %r15d
movq %r15, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop