LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa70d(%rip), %rax      # 0xf258
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rax, (%rsp)
addq $0x20, %rdi
callq 0x33b2
addq $0x28, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x33b2
pushq $0x22
popq %rsi
movq %r15, %rdi
callq 0x5a28
leaq 0x536f(%rip), %rcx      # 0x9ef0
cmpq (%rcx), %rax
jne 0x4be6
testq %r14, %r14
je 0x4bad
movq 0x8(%rsp), %rdx
addq $0x10, %rdx
movq (%rsp), %rcx
addq $0x10, %rcx
leaq 0x47a7(%rip), %rsi      # 0x934a
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x4c48
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5a30
leaq 0x4870(%rip), %rsi      # 0x943a
movq %rbx, %rdi
callq 0x5a40
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5a30
leaq 0x4857(%rip), %rsi      # 0x943b
jmp 0x4c40
testq %r14, %r14
je 0x4c0d
movq 0x8(%rsp), %rdx
addq $0x10, %rdx
movq (%rsp), %rcx
addq $0x10, %rcx
leaq 0x474f(%rip), %rsi      # 0x9352
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x4c48
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5a30
leaq 0x4734(%rip), %rsi      # 0x935a
movq %rbx, %rdi
callq 0x5a40
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5a30
leaq 0x471b(%rip), %rsi      # 0x935b
movq %rbx, %rdi
callq 0x5a40
movq %rsp, %rdi
callq 0x5cd8
leaq 0x8(%rsp), %rdi
callq 0x5cd8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5cd8
leaq 0x8(%rsp), %rdi
callq 0x5cd8
movq %rbx, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x4d77
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
testl %edx, %edx
cmovgl %edx, %ebp
leaq 0x4571(%rip), %r15      # 0x92a1
pushq $0x4
popq %r12
pushq $0x1
popq %r13
subl $0x1, %ebp
jb 0x4d50
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x32a0
jmp 0x4d38
movq 0x38(%r14), %rdx
addq $0x10, %rdx
leaq 0x463c(%rip), %rsi      # 0x939b
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
leaq 0x44e9(%rip), %rdi      # 0x9267
leaq 0x42b2(%rip), %rsi      # 0x9037
leaq 0x45db(%rip), %rcx      # 0x9367
movl $0x513, %edx            # imm = 0x513
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x4eb5
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x50(%rdi)
jne 0x4e4c
movl %edx, %r15d
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x31c0
xorl %ebp, %ebp
testl %r15d, %r15d
cmovgl %r15d, %ebp
leaq 0x4475(%rip), %r15      # 0x92a1
pushq $0x4
popq %r12
pushq $0x1
popq %r13
subl $0x1, %ebp
jb 0x4e8e
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x32a0
jmp 0x4e34
leaq 0xa405(%rip), %rax      # 0xf258
movq %rsp, %rsi
movq %rax, (%rsi)
addq $0x38, %r14
movq %r14, %rdi
callq 0x33b2
movq %rsp, %r14
movq (%r14), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x3180
movq %r14, %rdi
callq 0x5cd8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%r14), %rdx
addq $0x10, %rdx
leaq 0x4539(%rip), %rsi      # 0x93d6
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
leaq 0x43ab(%rip), %rdi      # 0x9267
leaq 0x4174(%rip), %rsi      # 0x9037
leaq 0x44db(%rip), %rcx      # 0x93a5
movl $0x536, %edx            # imm = 0x536
callq 0x30e0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5cd8
movq %rbx, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3566
leaq 0x50(%r14), %rsi
leaq 0x50(%rbx), %rdi
callq 0x5a18
leaq 0x58(%r14), %rsi
leaq 0x58(%rbx), %rdi
callq 0x5a18
addq $0x60, %r14
addq $0x60, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5a18
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x5121
leaq 0x42d3(%rip), %rdi      # 0x93e6
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x32a0
testq %rbx, %rbx
je 0x5135
leaq 0x42b9(%rip), %rsi      # 0x93e6
movq %rbx, %rdi
callq 0x5a40
movq 0x50(%r15), %rdx
cmpq $0x0, (%rdx)
je 0x518b
testq %r14, %r14
je 0x5159
addq $0x10, %rdx
leaq 0x429e(%rip), %rsi      # 0x93ed
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x518b
leaq 0x50(%r15), %r12
leaq 0x4292(%rip), %rsi      # 0x93fb
movq %rbx, %rdi
callq 0x5a40
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5a30
leaq 0x42aa(%rip), %rsi      # 0x942d
movq %rbx, %rdi
callq 0x5a40
movq 0x58(%r15), %rdx
cmpq $0x0, (%rdx)
je 0x51e1
testq %r14, %r14
je 0x51af
addq $0x10, %rdx
leaq 0x4260(%rip), %rsi      # 0x9405
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x51e1
leaq 0x58(%r15), %r12
leaq 0x4255(%rip), %rsi      # 0x9414
movq %rbx, %rdi
callq 0x5a40
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5a30
leaq 0x4254(%rip), %rsi      # 0x942d
movq %rbx, %rdi
callq 0x5a40
movq 0x60(%r15), %rdx
cmpq $0x0, (%rdx)
je 0x5237
testq %r14, %r14
je 0x5205
addq $0x10, %rdx
leaq 0x4224(%rip), %rsi      # 0x941f
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
testq %rbx, %rbx
je 0x5237
addq $0x60, %r15
leaq 0x421b(%rip), %rsi      # 0x9430
movq %rbx, %rdi
callq 0x5a40
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5a30
leaq 0x41fe(%rip), %rsi      # 0x942d
movq %rbx, %rdi
callq 0x5a40
testq %r14, %r14
je 0x5251
leaq 0x41fa(%rip), %rdi      # 0x943d
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x32a0
testq %rbx, %rbx
je 0x5270
leaq 0x41e0(%rip), %rsi      # 0x943d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5a40
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
addq $0x10, %rsi
callq 0x3b2c
testq %rax, %rax
jne 0x5436
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 %r14
retq
leaq 0x4066(%rip), %rdi      # 0x94a3
leaq 0x3bf3(%rip), %rsi      # 0x9037
leaq 0x406f(%rip), %rcx      # 0x94ba
movl $0x5ef, %edx            # imm = 0x5EF
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x546a
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
jne 0x546c
xorl %ecx, %ecx
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x5489
movq %rdx, %rsi
callq 0x399e
testq %rax, %rax
jne 0x548b
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x54aa
callq 0x3bae
testq %rax, %rax
jne 0x54ac
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x54cd
movq %rdx, %rsi
callq 0x3be0
testq %rax, %rax
jne 0x54cf
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5502
addq $0x28, %rcx
xorl %esi, %esi
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x54fd
cmpl %edx, %esi
jge 0x54fd
addq $0x48, %rcx
incl %esi
jmp 0x54e9
testq %rcx, %rcx
jne 0x5504
xorl %ecx, %ecx
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x5549
movl %ecx, %ebp
movq %rdx, %r14
movq %rdx, %rsi
callq 0x399e
xorl %r15d, %r15d
testq %rax, %rax
je 0x5544
cmpl %ebp, %r15d
jge 0x5544
movq %rax, %rdi
movq %r14, %rsi
callq 0x3a8a
incl %r15d
jmp 0x552a
testq %rax, %rax
jne 0x554b
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x5591
movl %edx, %ebp
callq 0x3bae
xorl %r14d, %r14d
testq %rax, %rax
je 0x558c
cmpl %ebp, %r14d
jge 0x558c
movq %rax, %rdi
callq 0x3c2a
incl %r14d
jmp 0x5575
testq %rax, %rax
jne 0x5593
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55df
movl %ecx, %ebp
movq %rdx, %r14
movq %rdx, %rsi
callq 0x3be0
xorl %r15d, %r15d
testq %rax, %rax
je 0x55da
cmpl %ebp, %r15d
jge 0x55da
movq %rax, %rdi
movq %r14, %rsi
callq 0x3c54
incl %r15d
jmp 0x55c0
testq %rax, %rax
jne 0x55e1
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
callq 0x5b62
leaq 0x10(%rbx), %r15
leaq 0x3efd(%rip), %rsi      # 0x9519
movq %r15, %rdi
callq 0x5a40
movq 0x38(%r14), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0x5a40
leaq 0x3c69(%rip), %r13      # 0x92a4
testq %r12, %r12
je 0x5665
movq %r15, %rdi
movq %r13, %rsi
callq 0x5a40
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x4b32
movq %r12, %rdi
callq 0x442e
movq %rax, %r12
jmp 0x563b
cmpq $0x0, 0x28(%r14)
je 0x56a6
leaq 0x3d30(%rip), %rsi      # 0x93a3
movq %r15, %rdi
callq 0x5a40
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
je 0x56b5
movq 0x28(%r14), %rdi
cmpq %rdi, 0x30(%r14)
jne 0x56b5
movq (%rdi), %rax
callq *0x40(%rax)
cmpb $0x0, 0x50(%rax)
jne 0x56b5
movb $0x1, 0xc(%rbx)
jmp 0x56bd
leaq 0x3bfd(%rip), %rsi      # 0x92aa
movq %r15, %rdi
callq 0x5a40
movq %rbx, %rdi
callq 0x5b96
incl 0x8(%rbx)
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5734
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, %r14
cmpb $0x1, 0xc(%rdi)
jne 0x56ed
movb $0x0, 0xc(%rbx)
jmp 0x56f5
movq %rbx, %rdi
callq 0x5b62
leaq 0x10(%rbx), %r15
leaq 0x3e1b(%rip), %rsi      # 0x951b
movq %r15, %rdi
callq 0x5a40
movq 0x38(%r14), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0x5a40
leaq 0x3c84(%rip), %rsi      # 0x93a3
movq %r15, %rdi
callq 0x5a40
movq %rbx, %rdi
callq 0x5b96
popq %rbx
popq %r14
popq %r15
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5791
movq %rbx, %rdi
callq 0x5b62
leaq 0x10(%rbx), %r15
leaq 0x3dbe(%rip), %rsi      # 0x951e
movq %r15, %rdi
callq 0x5a40
movq 0x38(%r14), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0x5a40
leaq 0x3da9(%rip), %rsi      # 0x9528
movq %r15, %rdi
callq 0x5a40
movq %rbx, %rdi
callq 0x5b96
jmp 0x5808
cmpb $0x1, 0xc(%rbx)
jne 0x57c5
leaq 0x9aba(%rip), %rax      # 0xf258
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
addq $0x38, %r14
movq %r14, %rdi
callq 0x33b2
addq $0x10, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5a30
jmp 0x57fe
movq %rbx, %rdi
callq 0x5b62
leaq 0x9a84(%rip), %rax      # 0xf258
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
addq $0x38, %r14
movq %r14, %rdi
callq 0x33b2
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5a30
movq %rbx, %rdi
callq 0x5b96
leaq 0x8(%rsp), %rdi
callq 0x5cd8
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5816
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5cd8
movq %rbx, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5b62
leaq 0x10(%r14), %rcx
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *0x90(%rax)
movq %r14, %rdi
callq 0x5b96
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlPrinter::Visit(TiXmlComment const&)
bool TiXmlPrinter::Visit( const TiXmlComment& comment )
{
	DoIndent();
	buffer += "<!--";
	buffer += comment.Value();
	buffer += "-->";
	DoLineBreak();
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5b62
leaq 0x10(%r14), %r15
leaq 0x3caf(%rip), %rsi      # 0x952c
movq %r15, %rdi
callq 0x5a40
movq 0x38(%rbx), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0x5a40
leaq 0x3b05(%rip), %rsi      # 0x93a1
movq %r15, %rdi
callq 0x5a40
movq %r14, %rdi
callq 0x5b96
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlPrinter::Visit(TiXmlUnknown const&)
bool TiXmlPrinter::Visit( const TiXmlUnknown& unknown )
{
	DoIndent();
	buffer += "<";
	buffer += unknown.Value();
	buffer += ">";
	DoLineBreak();
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5b62
leaq 0x10(%r14), %r15
leaq 0x3c4a(%rip), %rsi      # 0x9519
movq %r15, %rdi
callq 0x5a40
movq 0x38(%rbx), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0x5a40
leaq 0x3ab5(%rip), %rsi      # 0x93a3
movq %r15, %rdi
callq 0x5a40
movq %r14, %rdi
callq 0x5b96
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::~TiXmlNode()
TiXmlNode::~TiXmlNode()
{
	TiXmlNode* node = firstChild;
	TiXmlNode* temp = 0;

	while ( node )
	{
		temp = node;
		node = node->next;
		delete temp;
	}	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8e6c(%rip), %rax      # 0xe780
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x592f
movq (%rdi), %rax
movq 0x48(%rdi), %r14
callq *0x8(%rax)
movq %r14, %rdi
jmp 0x591b
addq $0x38, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5cd8
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/./tinyxml.h
// Function: TiXmlDocument::ClearError()
void ClearError()						{	error = false; 
												errorId = 0; 
												errorDesc = ""; 
												errorLocation.row = errorLocation.col = 0; 
												//errorLocation.last = 0; 
											}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x50(%rdi)
andl $0x0, 0x54(%rdi)
addq $0x58, %rdi
leaq 0x3a14(%rip), %rsi      # 0x93e5
callq 0x5988
andq $0x0, 0x64(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/./tinystr.h
// Function: TiXmlString::init(unsigned long, unsigned long)
void init(size_type sz, size_type cap)
	{
		if (cap)
		{
			// Lee: the original form:
			//	rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
			// doesn't work in some cases of new being overloaded. Switching
			// to the normal allocation, although use an 'int' for systems
			// that are overly picky about structure alignment.
			const size_type bytesNeeded = sizeof(Rep) + cap;
			const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); 
			rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );

			rep_->str[ rep_->size = sz ] = '\0';
			rep_->capacity = cap;
		}
		else
		{
			rep_ = &nullrep_;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0x5d2b
movq %rdx, %r14
movq %rsi, %r15
leaq 0x1b(%rdx), %rdi
andq $-0x4, %rdi
callq 0x3040
movq %r15, (%rax)
movb $0x0, 0x10(%rax,%r15)
movq %r14, 0x8(%rax)
jmp 0x5d32
leaq 0x9526(%rip), %rax      # 0xf258
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlBase::ConvertUTF32ToUTF8(unsigned long, char*, int*)
void TiXmlBase::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
{
	const unsigned long BYTE_MASK = 0xBF;
	const unsigned long BYTE_MARK = 0x80;
	const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };

	if (input < 0x80) 
		*length = 1;
	else if ( input < 0x800 )
		*length = 2;
	else if ( input < 0x10000 )
		*length = 3;
	else if ( input < 0x200000 )
		*length = 4;
	else
		{ *length = 0; return; }	// This code won't covert this correctly anyway.

	output += *length;

	// Scary scary fall throughs.
	switch (*length) 
	{
		case 4:
			--output; 
			*output = (char)((input | BYTE_MARK) & BYTE_MASK); 
			input >>= 6;
		case 3:
			--output; 
			*output = (char)((input | BYTE_MARK) & BYTE_MASK); 
			input >>= 6;
		case 2:
			--output; 
			*output = (char)((input | BYTE_MARK) & BYTE_MASK); 
			input >>= 6;
		case 1:
			--output; 
			*output = (char)(input | FIRST_BYTE_MARK[*length]);
	}
}

// Assembly:
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
movq $0xc0, -0x28(%rsp)
movq $0xe0, -0x20(%rsp)
movq $0xf0, -0x18(%rsp)
movq $0xf8, -0x10(%rsp)
movq $0xfc, -0x8(%rsp)
cmpq $0x80, %rdi
jae 0x5db8
movl $0x1, (%rdx)
movabsq $0x1, %rax
jmp 0x5e13
cmpq $0x7ff, %rdi            # imm = 0x7FF
ja 0x5dc9
movl $0x2, (%rdx)
jmp 0x5e03
cmpq $0xffff, %rdi           # imm = 0xFFFF
ja 0x5dda
movl $0x3, (%rdx)
jmp 0x5df6
cmpq $0x200000, %rdi         # imm = 0x200000
jae 0x5e1b
movl $0x4, (%rdx)
movl %edi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x3(%rsi)
shrq $0x6, %rdi
movl %edi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsi)
shrq $0x6, %rdi
movl %edi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
shrq $0x6, %rdi
movslq (%rdx), %rax
orl -0x38(%rsp,%rax,8), %edi
movb %dil, (%rsi)
retq
andl $0x0, (%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlBase::SkipWhiteSpace(char const*, TiXmlEncoding)
const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding )
{
	if ( !p || !*p )
	{
		return 0;
	}
	if ( encoding == TIXML_ENCODING_UTF8 )
	{
		while ( *p )
		{
			const unsigned char* pU = (const unsigned char*)p;
			
			// Skip the stupid Microsoft UTF-8 Byte order marks
			if (	*(pU+0)==TIXML_UTF_LEAD_0
				 && *(pU+1)==TIXML_UTF_LEAD_1 
				 && *(pU+2)==TIXML_UTF_LEAD_2 )
			{
				p += 3;
				continue;
			}
			else if(*(pU+0)==TIXML_UTF_LEAD_0
				 && *(pU+1)==0xbfU
				 && *(pU+2)==0xbeU )
			{
				p += 3;
				continue;
			}
			else if(*(pU+0)==TIXML_UTF_LEAD_0
				 && *(pU+1)==0xbfU
				 && *(pU+2)==0xbfU )
			{
				p += 3;
				continue;
			}

			if ( IsWhiteSpace( *p ) )		// Still using old rules for white space.
				++p;
			else
				break;
		}
	}
	else
	{
		while ( *p && IsWhiteSpace( *p ) )
			++p;
	}

	return p;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x6063
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x6063
cmpl $0x1, %esi
jne 0x604b
cmpb $-0x11, %al
je 0x600d
movzbl %al, %ecx
testl %ecx, %ecx
jne 0x6035
jmp 0x6065
movzbl 0x1(%rbx), %ecx
cmpl $0xbf, %ecx
je 0x6023
cmpl $0xbb, %ecx
je 0x6029
jmp 0x6035
cmpb $-0x42, 0x2(%rbx)
je 0x602f
cmpb $-0x41, 0x2(%rbx)
jne 0x6035
addq $0x3, %rbx
jmp 0x6047
movsbl %al, %edi
callq 0x7582
movzbl %al, %eax
addq %rax, %rbx
testb %al, %al
je 0x6065
movb (%rbx), %al
jmp 0x6000
testb %al, %al
je 0x6065
movsbl %al, %edi
callq 0x7582
testb %al, %al
je 0x6065
movb 0x1(%rbx), %al
incq %rbx
jmp 0x604b
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlBase::ReadName(char const*, TiXmlString*, TiXmlEncoding)
const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding )
{
	// Oddly, not supported on some comilers,
	//name->clear();
	// So use this:
	*name = "";
	assert( p );

	// Names start with letters or underscores.
	// Of course, in unicode, tinyxml has no idea what a letter *is*. The
	// algorithm is generous.
	//
	// After that, they can be letters, underscores, numbers,
	// hyphens, or colons. (Colons are valid ony for namespaces,
	// but tinyxml can't tell namespaces from names.)
	if (    p && *p 
		 && ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) )
	{
		const char* start = p;
		while(		p && *p
				&&	(		IsAlphaNum( (unsigned char ) *p, encoding ) 
						 || *p == '_'
						 || *p == '-'
						 || *p == '.'
						 || *p == ':' ) )
		{
			//(*name) += *p; // expensive
			++p;
		}
		if ( p-start > 0 ) {
			name->assign( start, p-start );
		}
		return p;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3363(%rip), %rsi      # 0x93e5
movq %r14, %rdi
callq 0x5988
testq %rbx, %rbx
je 0x6118
movb (%rbx), %bpl
testb %bpl, %bpl
je 0x60ae
movzbl %bpl, %edi
callq 0x5e20
cmpb $0x5f, %bpl
je 0x60b3
testl %eax, %eax
jne 0x60b3
xorl %r12d, %r12d
jmp 0x6106
xorl %r15d, %r15d
movabsq $0x4000000002003, %r13  # imm = 0x4000000002003
testb %bpl, %bpl
je 0x60ef
movzbl %bpl, %r12d
movl %r12d, %edi
callq 0x5e34
testl %eax, %eax
jne 0x60e5
addl $-0x2d, %r12d
cmpl $0x32, %r12d
ja 0x60ef
btq %r12, %r13
jae 0x60ef
movb 0x1(%rbx,%r15), %bpl
incq %r15
jmp 0x60c0
leaq (%rbx,%r15), %r12
testq %r15, %r15
jle 0x6106
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x7802
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31f4(%rip), %rdi      # 0x9313
leaq 0x34f8(%rip), %rsi      # 0x961e
leaq 0x355f(%rip), %rcx      # 0x968c
movl $0x197, %edx            # imm = 0x197
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlBase::StringEqual(char const*, char const*, bool, TiXmlEncoding)
bool TiXmlBase::StringEqual( const char* p,
							 const char* tag,
							 bool ignoreCase,
							 TiXmlEncoding encoding )
{
	assert( p );
	assert( tag );
	if ( !p || !*p )
	{
		assert( 0 );
		return false;
	}

	const char* q = p;

	if ( ignoreCase )
	{
		while ( *q && *tag && ToLower( *q, encoding ) == ToLower( *tag, encoding ) )
		{
			++q;
			++tag;
		}

		if ( *tag == 0 )
			return true;
	}
	else
	{
		while ( *q && *tag && *q == *tag )
		{
			++q;
			++tag;
		}

		if ( *tag == 0 )		// Have we found the end of the tag, and everything equal?
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x63c1
movq %rsi, %rbx
testq %rsi, %rsi
je 0x63e0
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
je 0x63ff
testb %dl, %dl
je 0x6390
movl %ecx, %ebp
xorl %r12d, %r12d
testb %al, %al
je 0x63af
cmpb $0x0, (%rbx,%r12)
je 0x63b6
movsbl %al, %edi
movl %ebp, %esi
callq 0x75a6
movl %eax, %r15d
movsbl (%rbx,%r12), %edi
movl %ebp, %esi
callq 0x75a6
cmpl %eax, %r15d
jne 0x63af
movb 0x1(%r14,%r12), %al
incq %r12
jmp 0x635d
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
testb %al, %al
je 0x63a7
cmpb %dl, %al
jne 0x63a7
movb 0x1(%r14,%rcx), %al
incq %rcx
jmp 0x6392
testb %dl, %dl
je 0x63b6
xorl %eax, %eax
jmp 0x63b8
cmpb $0x0, (%rbx,%r12)
jne 0x63ab
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f4b(%rip), %rdi      # 0x9313
leaq 0x324f(%rip), %rsi      # 0x961e
leaq 0x338c(%rip), %rcx      # 0x9762
movl $0x21b, %edx            # imm = 0x21B
callq 0x30e0
leaq 0x33cf(%rip), %rdi      # 0x97b6
leaq 0x3230(%rip), %rsi      # 0x961e
leaq 0x336d(%rip), %rcx      # 0x9762
movl $0x21c, %edx            # imm = 0x21C
callq 0x30e0
leaq 0x2d73(%rip), %rdi      # 0x9179
leaq 0x3211(%rip), %rsi      # 0x961e
leaq 0x334e(%rip), %rcx      # 0x9762
movl $0x21f, %edx            # imm = 0x21F
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlDocument::SetError(int, char const*, TiXmlParsingData*, TiXmlEncoding)
void TiXmlDocument::SetError( int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding )
{	
	// The first error in a chain is more accurate - don't set again!
	if ( error )
		return;

	assert( err > 0 && err < TIXML_ERROR_STRING_COUNT );
	error   = true;
	errorId = err;
	errorDesc = errorString[ errorId ];

	errorLocation.Clear();
	if ( pError && data )
	{
		data->Stamp( pError, encoding );
		errorLocation = data->Cursor();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x50(%rdi)
jne 0x67c7
leal -0x1(%rsi), %eax
cmpl $0xf, %eax
jae 0x67d2
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movb $0x1, 0x50(%rdi)
movl %esi, 0x54(%rdi)
movl %esi, %eax
leaq 0x8a3f(%rip), %rcx      # 0xf1d0
movq (%rcx,%rax,8), %rsi
addq $0x58, %rdi
callq 0x5988
orq $-0x1, 0x64(%r14)
testq %r15, %r15
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x67c7
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5e48
movq (%rbx), %rax
movq %rax, 0x64(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2fec(%rip), %rdi      # 0x97c5
leaq 0x2e3e(%rip), %rsi      # 0x961e
leaq 0x3008(%rip), %rcx      # 0x97ef
movl $0x324, %edx            # imm = 0x324
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlElement::ReadValue(char const*, TiXmlParsingData*, TiXmlEncoding)
const char* TiXmlElement::ReadValue( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
{
	TiXmlDocument* document = GetDocument();

	// Read in text and elements in any order.
	const char* pWithWhiteSpace = p;
	p = SkipWhiteSpace( p, encoding );

	while ( p && *p )
	{
		if ( *p != '<' )
		{
			// Take what we have, make a text element.
			TiXmlText* textNode = new TiXmlText( "" );

			if ( !textNode )
			{
			    return 0;
			}

			if ( TiXmlBase::IsWhiteSpaceCondensed() )
			{
				p = textNode->Parse( p, data, encoding );
			}
			else
			{
				// Special case: we want to keep the white space
				// so that leading spaces aren't removed.
				p = textNode->Parse( pWithWhiteSpace, data, encoding );
			}

			if ( !textNode->Blank() )
				LinkEndChild( textNode );
			else
				delete textNode;
		} 
		else 
		{
			// We hit a '<'
			// Have we hit a new element or an end tag? This could also be
			// a TiXmlText in the "CDATA" style.
			if ( StringEqual( p, "</", false, encoding ) )
			{
				return p;
			}
			else
			{
				TiXmlNode* node = Identify( p, encoding );
				if ( node )
				{
					p = node->Parse( p, data, encoding );
					LinkEndChild( node );
				}				
				else
				{
					return 0;
				}
			}
		}
		pWithWhiteSpace = p;
		p = SkipWhiteSpace( p, encoding );
	}

	if ( !p )
	{
		if ( document ) document->SetError( TIXML_ERROR_READING_ELEMENT_VALUE, 0, 0, encoding );
	}	
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
callq 0x3c9a
movq %rax, (%rsp)
movq %r13, %rdi
movl %ebx, %esi
callq 0x5fec
testq %rax, %rax
je 0x6da2
movq %rax, %rbp
movzbl (%rax), %eax
cmpl $0x3c, %eax
je 0x6d22
testl %eax, %eax
je 0x6dc0
pushq $0x58
popq %rdi
callq 0x3130
movq %rax, %r14
movq %rax, %rdi
leaq 0x26e3(%rip), %rsi      # 0x93e5
callq 0x5a80
movq (%r14), %rax
movq 0x18(%rax), %rax
leaq 0x845b(%rip), %rcx      # 0xf170
cmpb $0x1, (%rcx)
jne 0x6d68
movq %r14, %rdi
movq %rbp, %rsi
jmp 0x6d6e
movq %rbp, %rdi
leaq 0x27ef(%rip), %rsi      # 0x951b
xorl %edx, %edx
movl %ebx, %ecx
callq 0x632a
testb %al, %al
jne 0x6dc0
movq %r12, %rdi
movq %rbp, %rsi
movl %ebx, %edx
callq 0x67f2
testq %rax, %rax
je 0x6dbe
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movl %ebx, %ecx
callq *0x18(%rax)
movq %rax, %r13
jmp 0x6d92
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movl %ebx, %ecx
callq *%rax
movq %rax, %r13
movq %r14, %rdi
callq 0x6de8
testb %al, %al
je 0x6d92
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x6cc7
movq %r12, %rdi
movq %r14, %rsi
callq 0x35cc
jmp 0x6cc7
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6dbe
xorl %ebp, %ebp
pushq $0x5
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl %ebx, %r8d
callq 0x6760
jmp 0x6dc0
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlText::Blank() const
bool TiXmlText::Blank() const
{
	for ( unsigned i=0; i<value.length(); i++ )
		if ( !IsWhiteSpace( value[i] ) )
			return false;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x38, %rbx
xorl %ecx, %ecx
movl %ecx, %r14d
movq (%rbx), %rax
movq (%rax), %r15
cmpq %r14, %r15
jbe 0x6e1f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5942
movsbl (%rax), %edi
callq 0x7582
leal 0x1(%r14), %ecx
testb %al, %al
jne 0x6df6
cmpq %r14, %r15
setbe %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlUnknown::Parse(char const*, TiXmlParsingData*, TiXmlEncoding)
const char* TiXmlUnknown::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
{
	TiXmlDocument* document = GetDocument();
	p = SkipWhiteSpace( p, encoding );

	if ( data )
	{
		data->Stamp( p, encoding );
		location = data->Cursor();
	}
	if ( !p || !*p || *p != '<' )
	{
		if ( document ) document->SetError( TIXML_ERROR_PARSING_UNKNOWN, p, data, encoding );
		return 0;
	}
	++p;
    value = "";

	while ( p && *p && *p != '>' )
	{
		value += *p;
		++p;
	}

	if ( !p )
	{
		if ( document )	
			document->SetError( TIXML_ERROR_PARSING_UNKNOWN, 0, 0, encoding );
	}
	if ( p && *p == '>' )
		return p+1;
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3c9a
movq %rax, %r12
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5fec
movq %rax, %rbx
testq %r15, %r15
je 0x6e6d
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5e48
movq (%r15), %rax
movq %rax, 0x8(%r14)
testq %rbx, %rbx
je 0x6ea6
cmpb $0x3c, (%rbx)
jne 0x6ea6
addq $0x38, %r14
leaq 0x2563(%rip), %rsi      # 0x93e5
movq %r14, %rdi
callq 0x5988
incq %rbx
movzbl (%rbx), %ecx
testl %ecx, %ecx
je 0x6ec3
cmpl $0x3e, %ecx
je 0x6ec3
movsbl %cl, %esi
movq %r14, %rdi
callq 0x5972
jmp 0x6e8a
testq %r12, %r12
je 0x6ebf
pushq $0x9
popq %rsi
movq %r12, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movl %ebp, %r8d
callq 0x6760
xorl %eax, %eax
jmp 0x6ece
leaq 0x1(%rbx), %rax
cmpb $0x3e, %cl
cmovneq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlComment::Parse(char const*, TiXmlParsingData*, TiXmlEncoding)
const char* TiXmlComment::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
{
	TiXmlDocument* document = GetDocument();
	value = "";

	p = SkipWhiteSpace( p, encoding );

	if ( data )
	{
		data->Stamp( p, encoding );
		location = data->Cursor();
	}
	const char* startTag = "<!--";
	const char* endTag   = "-->";

	if ( !StringEqual( p, startTag, false, encoding ) )
	{
		if ( document )
			document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding );
		return 0;
	}
	p += strlen( startTag );

	// [ 1475201 ] TinyXML parses entities in comments
	// Oops - ReadText doesn't work, because we don't want to parse the entities.
	// p = ReadText( p, &value, false, endTag, false, encoding );
	//
	// from the XML spec:
	/*
	 [Definition: Comments may appear anywhere in a document outside other markup; in addition, 
	              they may appear within the document type declaration at places allowed by the grammar. 
				  They are not part of the document's character data; an XML processor MAY, but need not, 
				  make it possible for an application to retrieve the text of comments. For compatibility, 
				  the string "--" (double-hyphen) MUST NOT occur within comments.] Parameter entity 
				  references MUST NOT be recognized within comments.

				  An example of a comment:

				  <!-- declarations for <head> & <body> -->
	*/

    value = "";
	// Keep all the white space.
	while (	p && *p && !StringEqual( p, endTag, false, encoding ) )
	{
		value.append( p, 1 );
		++p;
	}
	if ( p && *p ) 
		p += strlen( endTag );

	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
callq 0x3c9a
movq %rax, %r12
leaq 0x38(%r13), %r14
leaq 0x24e4(%rip), %rsi      # 0x93e5
movq %r14, %rdi
callq 0x5988
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5fec
movq %rax, %rbx
testq %r15, %r15
je 0x6f2f
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5e48
movq (%r15), %rax
movq %rax, 0x8(%r13)
leaq 0x25f6(%rip), %rsi      # 0x952c
movq %rbx, %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x632a
testb %al, %al
je 0x6f92
addq $0x4, %rbx
leaq 0x2494(%rip), %rsi      # 0x93e5
movq %r14, %rdi
callq 0x5988
xorl %r13d, %r13d
leaq 0x243e(%rip), %r15      # 0x93a1
pushq $0x1
popq %r12
cmpb $0x0, (%rbx)
je 0x6fbb
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x632a
testb %al, %al
jne 0x6faf
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x78b6
incq %rbx
jmp 0x6f67
testq %r12, %r12
je 0x6fab
pushq $0xa
popq %rsi
movq %r12, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movl %ebp, %r8d
callq 0x6760
xorl %ebx, %ebx
jmp 0x6fbe
xorl %eax, %eax
cmpb $0x0, (%rbx)
setne %al
leaq (%rax,%rax,2), %r13
addq %r13, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlText::Parse(char const*, TiXmlParsingData*, TiXmlEncoding)
const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
{
	value = "";
	TiXmlDocument* document = GetDocument();

	if ( data )
	{
		data->Stamp( p, encoding );
		location = data->Cursor();
	}

	const char* const startTag = "<![CDATA[";
	const char* const endTag   = "]]>";

	if ( cdata || StringEqual( p, startTag, false, encoding ) )
	{
		cdata = true;

		if ( !StringEqual( p, startTag, false, encoding ) )
		{
			if ( document )
				document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding );
			return 0;
		}
		p += strlen( startTag );

		// Keep all the white space, ignore the encoding, etc.
		while (	   p && *p
				&& !StringEqual( p, endTag, false, encoding )
			  )
		{
			value += *p;
			++p;
		}

		TIXML_STRING dummy; 
		p = ReadText( p, &dummy, false, endTag, false, encoding );
		return p;
	}
	else
	{
		bool ignoreWhite = true;

		const char* end = "<";
		p = ReadText( p, &value, ignoreWhite, end, false, encoding );
		if ( p && *p )
			return p-1;	// don't truncate the '<'
		return 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x38(%rdi), %r15
leaq 0x2284(%rip), %rsi      # 0x93e5
movq %r15, %rdi
callq 0x5988
movq %rbp, %rdi
callq 0x3c9a
movq %rax, %r13
testq %r12, %r12
je 0x718e
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5e48
movq (%r12), %rax
movq %rax, 0x8(%rbp)
cmpb $0x0, 0x50(%rbp)
jne 0x71af
leaq 0x2383(%rip), %rsi      # 0x951e
movq %r14, %rdi
xorl %edx, %edx
movl %ebx, %ecx
callq 0x632a
testb %al, %al
je 0x724e
movb $0x1, 0x50(%rbp)
leaq 0x2364(%rip), %rsi      # 0x951e
movq %r14, %rdi
xorl %edx, %edx
movl %ebx, %ecx
callq 0x632a
testb %al, %al
je 0x71ff
addq $0x9, %r14
leaq 0x2353(%rip), %r12      # 0x9528
cmpb $0x0, (%r14)
je 0x721d
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movl %ebx, %ecx
callq 0x632a
testb %al, %al
jne 0x721d
movsbl (%r14), %esi
movq %r15, %rdi
callq 0x5972
incq %r14
jmp 0x71d5
testq %r13, %r13
je 0x7218
pushq $0xe
popq %rsi
movq %r13, %rdi
movq %r14, %rdx
movq %r12, %rcx
movl %ebx, %r8d
callq 0x6760
xorl %r12d, %r12d
jmp 0x7281
leaq 0x8034(%rip), %rax      # 0xf258
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x22f7(%rip), %rcx      # 0x9528
movq %r14, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
movl %ebx, %r9d
callq 0x641e
movq %rax, %r12
movq %rsp, %rdi
callq 0x5cd8
jmp 0x7281
leaq 0x22c4(%rip), %rcx      # 0x9519
pushq $0x1
popq %rdx
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
movl %ebx, %r9d
callq 0x641e
testq %rax, %rax
je 0x7281
movq %rax, %rcx
decq %rcx
xorl %r12d, %r12d
cmpb $0x0, (%rax)
cmovneq %rcx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5cd8
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/./tinyxml.h
// Function: TiXmlBase::GetChar(char const*, char*, int*, TiXmlEncoding)
inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding )
	{
		assert( p );
		if ( encoding == TIXML_ENCODING_UTF8 )
		{
			*length = utf8ByteTable[ *((const unsigned char*)p) ];
			assert( *length >= 0 && *length < 5 );
		}
		else
		{
			*length = 1;
		}

		if ( *length == 1 )
		{
			if ( *p == '&' )
				return GetEntity( p, _value, length, encoding );
			*_value = *p;
			return p+1;
		}
		else if ( *length )
		{
			//strncpy( _value, p, *length );	// lots of compilers don't like this function (unsafe),
												// and the null terminator isn't needed
			for( int i=0; p[i] && i<*length; ++i ) {
				_value[i] = p[i];
			}
			return p + (*length);
		}
		else
		{
			// Not valid text.
			return 0;
		}
	}

// Assembly:
testq %rdi, %rdi
je 0x7623
cmpl $0x1, %ecx
jne 0x7600
movzbl (%rdi), %eax
leaq 0x22fe(%rip), %r8       # 0x98d0
movl (%r8,%rax,4), %r8d
movl %r8d, (%rdx)
testl %r8d, %r8d
je 0x7618
cmpl $0x1, %r8d
je 0x7606
xorl %eax, %eax
movb (%rdi,%rax), %cl
movslq %r8d, %r8
testb %cl, %cl
je 0x761c
cmpq %r8, %rax
jge 0x761c
movb %cl, (%rsi,%rax)
incq %rax
movl (%rdx), %r8d
jmp 0x75e6
movl $0x1, (%rdx)
movb (%rdi), %al
cmpb $0x26, %al
jne 0x7611
jmp 0x6138
movb %al, (%rsi)
incq %rdi
jmp 0x761f
xorl %edi, %edi
jmp 0x761f
addq %r8, %rdi
movq %rdi, %rax
retq
pushq %rax
leaq 0x1ce8(%rip), %rdi      # 0x9313
leaq 0x2235(%rip), %rsi      # 0x9867
leaq 0x223a(%rip), %rcx      # 0x9873
movl $0x149, %edx            # imm = 0x149
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/xmlexample.cpp
// Function: main
int main()
{
    TiHtmlDocument doc;
    doc.ParseURL( "test.html" );

    /* Get Album */
    TiHtmlResult* result = doc.Query(".album/ul/li/a");
    if (result) {
        printf("count=%d\n", result->Count());
        for (int ii = 0; ii < result->Count(); ii++) {
            printf("channel:%s, rel:%s\n", result->Element(ii)->GetText(),  result->Element(ii)->Attribute("rel"));
        }
        delete(result);
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x809a
leaq 0x2633(%rip), %rsi      # 0x9cf1
movq %rbx, %rdi
callq 0x80e0
leaq 0x262e(%rip), %rsi      # 0x9cfb
movq %rsp, %rdi
callq 0x8146
movq %rax, %rbx
testq %rax, %rax
je 0x7758
movq %rbx, %rdi
callq 0x7c1c
leaq 0x261e(%rip), %rdi      # 0x9d0a
movl %eax, %esi
xorl %eax, %eax
callq 0x3050
leaq 0x262c(%rip), %r14      # 0x9d28
leaq 0x2611(%rip), %r15      # 0x9d14
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x7c1c
cmpl %eax, %ebp
jge 0x774f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7c20
movq %rax, %rdi
callq 0x7c9e
movq %rax, %r12
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7c20
movq %rax, %rdi
movq %r14, %rsi
callq 0x7c8e
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3050
incl %ebp
jmp 0x7705
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %rsp, %rdi
callq 0x8116
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7773
jmp 0x7773
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8116
movq %rbx, %rdi
callq 0x3280
nop