LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8210
testb $0x1, %al
jne 0x74e7
jmp 0x753f
movq -0x38(%rbp), %rdi
callq 0x8170
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
leaq 0x701f(%rip), %rsi      # 0xe51e
callq 0x7d30
movq -0x10(%rbp), %rdi
callq 0x7960
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0x7d30
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
leaq 0x6ffc(%rip), %rsi      # 0xe528
callq 0x7d30
movq -0x38(%rbp), %rdi
callq 0x81c0
jmp 0x761a
movq -0x38(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0x75a8
leaq -0x18(%rbp), %rdi
callq 0x78a0
movq -0x10(%rbp), %rdi
callq 0x8230
movq %rax, -0x40(%rbp)
jmp 0x7561
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x33c0
jmp 0x7570
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x7ce0
jmp 0x7583
leaq -0x18(%rbp), %rdi
callq 0x78c0
jmp 0x7618
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x78c0
jmp 0x7624
movq -0x38(%rbp), %rdi
callq 0x8170
leaq -0x30(%rbp), %rdi
callq 0x78a0
movq -0x10(%rbp), %rdi
callq 0x8230
movq %rax, -0x48(%rbp)
jmp 0x75c9
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x33c0
jmp 0x75d8
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
leaq -0x30(%rbp), %rsi
callq 0x7ce0
jmp 0x75eb
movq -0x38(%rbp), %rdi
callq 0x81c0
jmp 0x75f6
leaq -0x30(%rbp), %rdi
callq 0x78c0
jmp 0x7618
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x78c0
jmp 0x7624
jmp 0x761a
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x8170
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdi
addq $0x10, %rcx
movq (%rdi), %rax
xorl %edx, %edx
movl %edx, %esi
xorl %edx, %edx
callq *0x90(%rax)
movq -0x18(%rbp), %rdi
callq 0x81c0
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x8170
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0x6e80(%rip), %rsi      # 0xe52c
callq 0x7d30
movq -0x10(%rbp), %rdi
callq 0x7960
movq -0x18(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0x7d30
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0x6cc8(%rip), %rsi      # 0xe3a1
callq 0x7d30
movq -0x18(%rbp), %rdi
callq 0x81c0
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x8170
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0x6ded(%rip), %rsi      # 0xe519
callq 0x7d30
movq -0x10(%rbp), %rdi
callq 0x7960
movq -0x18(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0x7d30
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0x6c4a(%rip), %rsi      # 0xe3a3
callq 0x7d30
movq -0x18(%rbp), %rdi
callq 0x81c0
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x0, 0x50(%rdi)
movl $0x0, 0x54(%rdi)
addq $0x58, %rdi
leaq 0x687b(%rip), %rsi      # 0xe3e5
callq 0x79c0
movq -0x10(%rbp), %rax
movl $0x0, 0x68(%rax)
movl $0x0, 0x64(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8741
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
movq (%rax), %rsi
movq %rdx, (%rsi)
movb $0x0, 0x10(%rcx,%rdx)
movq -0x18(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x874f
movq -0x30(%rbp), %rax
leaq 0xbafc(%rip), %rcx      # 0x14248
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: smallmuou[P]tinyhtml/./tinystr.h
// Function: TiXmlString::find(char, unsigned long) const
size_type find (char tofind, size_type offset) const
	{
		if (offset >= length()) return npos;

		for (const char* p = c_str() + offset; *p != '\0'; ++p)
		{
		   if (*p == tofind) return static_cast< size_type >( p - c_str() );
		}
		return npos;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x7780
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jb 0x87a7
leaq 0x681a(%rip), %rax      # 0xefb8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8812
movq -0x38(%rbp), %rdi
callq 0x7810
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x8804
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x87f4
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x7810
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8812
jmp 0x87f6
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x87b8
leaq 0x67ad(%rip), %rax      # 0xefb8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0xbf, -0x20(%rbp)
movq $0x80, -0x28(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x30d0
movq $0xc0, -0x50(%rbp)
movq $0xe0, -0x48(%rbp)
movq $0xf0, -0x40(%rbp)
movq $0xf8, -0x38(%rbp)
movq $0xfc, -0x30(%rbp)
cmpq $0x80, -0x8(%rbp)
jae 0x88c2
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x8919
cmpq $0x800, -0x8(%rbp)      # imm = 0x800
jae 0x88d8
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
jmp 0x8917
cmpq $0x10000, -0x8(%rbp)    # imm = 0x10000
jae 0x88ee
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
jmp 0x8915
cmpq $0x200000, -0x8(%rbp)   # imm = 0x200000
jae 0x8904
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
jmp 0x8913
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x8a0a
jmp 0x8915
jmp 0x8917
jmp 0x8919
movq -0x18(%rbp), %rax
movslq (%rax), %rcx
movq -0x10(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x68(%rbp)
subl $0x3, %eax
ja 0x8a0a
movq -0x68(%rbp), %rax
leaq 0x5cb3(%rip), %rcx      # 0xe600
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
orq $0x80, %rax
andq $0xbf, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
orq $0x80, %rax
andq $0xbf, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
orq $0x80, %rax
andq $0xbf, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
orq -0x60(%rbp,%rcx,8), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
addq $0x70, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8e1f
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x8e2c
movq $0x0, -0x8(%rbp)
jmp 0x8f6e
cmpl $0x1, -0x14(%rbp)
jne 0x8f2e
jmp 0x8e38
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8f2c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xef, %eax
jne 0x8e87
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xbb, %eax
jne 0x8e87
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xbf, %eax
jne 0x8e87
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
jmp 0x8e38
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xef, %eax
jne 0x8ec4
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xbf, %eax
jne 0x8ec4
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xbe, %eax
jne 0x8ec4
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
jmp 0x8e38
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xef, %eax
jne 0x8f01
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xbf, %eax
jne 0x8f01
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xbf, %eax
jne 0x8f01
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
jmp 0x8e38
jmp 0x8f03
jmp 0x8f05
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0xb690
testb $0x1, %al
jne 0x8f17
jmp 0x8f25
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8f27
jmp 0x8f2c
jmp 0x8e38
jmp 0x8f66
jmp 0x8f30
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x8f4d
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0xb690
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x8f56
jmp 0x8f64
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8f30
jmp 0x8f66
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x5447(%rip), %rsi      # 0xe3e5
callq 0x79c0
cmpq $0x0, -0x10(%rbp)
je 0x8fac
jmp 0x8fcb
leaq 0x5360(%rip), %rdi      # 0xe313
leaq 0x5a99(%rip), %rsi      # 0xea53
movl $0x197, %edx            # imm = 0x197
leaq 0x5b01(%rip), %rcx      # 0xeac7
callq 0x30e0
cmpq $0x0, -0x10(%rbp)
je 0x90de
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x90de
movq -0x10(%rbp), %rax
movb (%rax), %al
movl -0x1c(%rbp), %esi
movzbl %al, %edi
callq 0x8a10
cmpl $0x0, %eax
jne 0x9009
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x90de
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0x9091
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x29(%rbp)
je 0x9091
movq -0x10(%rbp), %rax
movb (%rax), %al
movl -0x1c(%rbp), %esi
movzbl %al, %edi
callq 0x8a50
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
jne 0x908b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x5f, %ecx
movb %al, -0x2a(%rbp)
je 0x908b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x2a(%rbp)
je 0x908b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2e, %ecx
movb %al, -0x2a(%rbp)
je 0x908b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x909a
jmp 0x90ab
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9011
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
cmpq $0x0, %rax
jle 0x90d4
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
callq 0xbd20
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x90e6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl %ecx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9563
jmp 0x9582
leaq 0x4da9(%rip), %rdi      # 0xe313
leaq 0x54e2(%rip), %rsi      # 0xea53
movl $0x21b, %edx            # imm = 0x21B
leaq 0x5620(%rip), %rcx      # 0xeb9d
callq 0x30e0
cmpq $0x0, -0x18(%rbp)
je 0x958b
jmp 0x95aa
leaq 0x565f(%rip), %rdi      # 0xebf1
leaq 0x54ba(%rip), %rsi      # 0xea53
movl $0x21c, %edx            # imm = 0x21C
leaq 0x55f8(%rip), %rcx      # 0xeb9d
callq 0x30e0
cmpq $0x0, -0x10(%rbp)
je 0x95ba
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x95d9
leaq 0x4bb8(%rip), %rdi      # 0xe179
leaq 0x548b(%rip), %rsi      # 0xea53
movl $0x21f, %edx            # imm = 0x21F
leaq 0x55c9(%rip), %rcx      # 0xeb9d
callq 0x30e0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0x966e
jmp 0x95ed
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x29(%rbp)
je 0x9637
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x29(%rbp)
je 0x9637
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
movl -0x20(%rbp), %esi
callq 0xb6e0
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
movl -0x20(%rbp), %esi
callq 0xb6e0
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9640
jmp 0x965a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x95ed
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x966c
movb $0x1, -0x1(%rbp)
jmp 0x96dd
jmp 0x96d9
jmp 0x9670
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0x96a2
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0x96a2
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x96ab
jmp 0x96c5
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9670
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x96d7
movb $0x1, -0x1(%rbp)
jmp 0x96dd
jmp 0x96d9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x50(%rax)
je 0x9c7e
jmp 0x9d25
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x31(%rbp)
jle 0x9c93
cmpl $0x10, -0xc(%rbp)
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x9c9c
jmp 0x9c9e
jmp 0x9cbd
leaq 0x4fb9(%rip), %rdi      # 0xec5e
leaq 0x4da7(%rip), %rsi      # 0xea53
movl $0x324, %edx            # imm = 0x324
leaq 0x4fd0(%rip), %rcx      # 0xec88
callq 0x30e0
movq -0x30(%rbp), %rdi
movb $0x1, 0x50(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x54(%rdi)
movslq 0x54(%rdi), %rcx
leaq 0xa4ea(%rip), %rax      # 0x141c0
movq (%rax,%rcx,8), %rsi
addq $0x58, %rdi
callq 0x79c0
movq -0x30(%rbp), %rdi
addq $0x64, %rdi
callq 0x7c50
cmpq $0x0, -0x18(%rbp)
je 0x9d25
cmpq $0x0, -0x20(%rbp)
je 0x9d25
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x8a90
movq -0x20(%rbp), %rdi
callq 0xb950
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x64(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
callq 0x7780
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xa99c
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x77a0
movsbl (%rax), %edi
callq 0xb690
testb $0x1, %al
jne 0xa98f
movb $0x0, -0x1(%rbp)
jmp 0xa9a0
jmp 0xa991
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa94b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x7920
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x8e00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xaa16
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x8a90
movq -0x20(%rbp), %rdi
callq 0xb950
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xaa32
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0xaa32
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
je 0xaa60
cmpq $0x0, -0x30(%rbp)
je 0xaa53
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl $0x9, %esi
callq 0x9c50
movq $0x0, -0x8(%rbp)
jmp 0xab29
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
addq $0x38, %rdi
leaq 0x396a(%rip), %rsi      # 0xe3e5
callq 0x79c0
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x39(%rbp)
je 0xaaaa
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x39(%rbp)
je 0xaaaa
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xaab3
jmp 0xaad7
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movb (%rax), %al
addq $0x38, %rdi
movsbl %al, %esi
callq 0x7830
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xaa80
cmpq $0x0, -0x18(%rbp)
jne 0xab00
cmpq $0x0, -0x30(%rbp)
je 0xaafe
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %r8d
movl $0x9, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x9c50
jmp 0xab00
cmpq $0x0, -0x18(%rbp)
je 0xab21
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
jne 0xab21
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xab29
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/./tinyxml.h
// Function: TiXmlBase::ToLower(int, TiXmlEncoding)
inline static int ToLower( int v, TiXmlEncoding encoding )
	{
		if ( encoding == TIXML_ENCODING_UTF8 )
		{
			if ( v < 128 ) return tolower( v );
			return v;
		}
		else
		{
			return tolower( v );
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0xb712
cmpl $0x80, -0x8(%rbp)
jge 0xb70a
movl -0x8(%rbp), %edi
callq 0x31f0
movl %eax, -0x4(%rbp)
jmp 0xb71d
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb71d
movl -0x8(%rbp), %edi
callq 0x31f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb750
jmp 0xb76f
leaq 0x2bbc(%rip), %rdi      # 0xe313
leaq 0x35a2(%rip), %rsi      # 0xed00
movl $0x149, %edx            # imm = 0x149
leaq 0x35a2(%rip), %rcx      # 0xed0c
callq 0x30e0
cmpl $0x1, -0x24(%rbp)
jne 0xb7d5
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x2e8b(%rip), %rax      # 0xe610
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x29(%rbp)
jl 0xb7a9
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xb7b2
jmp 0xb7b4
jmp 0xb7d3
leaq 0x35a3(%rip), %rdi      # 0xed5e
leaq 0x353e(%rip), %rsi      # 0xed00
movl $0x14d, %edx            # imm = 0x14D
leaq 0x353e(%rip), %rcx      # 0xed0c
callq 0x30e0
jmp 0xb7df
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xb82b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0xb811
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x90f0
movq %rax, -0x8(%rbp)
jmp 0xb8a3
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xb8a3
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xb89b
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpb $0x0, (%rcx,%rdx)
movb %al, -0x2a(%rbp)
je 0xb85d
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
setl %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0xb866
jmp 0xb887
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xb83b
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xb8a3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxmlparser.cpp
// Function: TiXmlParsingData::TiXmlParsingData(char const*, int, int, int)
TiXmlParsingData( const char* start, int _tabsize, int row, int col )
	{
		assert( start );
		stamp = start;
		tabsize = _tabsize;
		cursor.row = row;
		cursor.col = col;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x7b20
cmpq $0x0, -0x10(%rbp)
je 0xb900
jmp 0xb91f
leaq 0x3473(%rip), %rdi      # 0xed7a
leaq 0x3145(%rip), %rsi      # 0xea53
movl $0xb7, %edx
leaq 0x3466(%rip), %rcx      # 0xed80
callq 0x30e0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xcf00
movq -0x40(%rbp), %rdi
leaq 0x32c6(%rip), %rsi      # 0xedc0
callq 0xcf80
jmp 0xbb01
leaq 0x32c2(%rip), %rsi      # 0xedca
leaq -0x18(%rbp), %rdi
callq 0xd0c0
movq %rax, -0x48(%rbp)
jmp 0xbb17
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xbc16
movq -0x30(%rbp), %rdi
callq 0xc500
movl %eax, -0x4c(%rbp)
jmp 0xbb38
movl -0x4c(%rbp), %esi
leaq 0x3297(%rip), %rdi      # 0xedd9
xorl %eax, %eax
callq 0x3050
jmp 0xbb4b
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc500
movl %eax, -0x50(%rbp)
jmp 0xbb66
movl -0x54(%rbp), %eax
movl -0x50(%rbp), %ecx
cmpl %ecx, %eax
jge 0xbbfc
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0xc520
movq %rax, -0x60(%rbp)
jmp 0xbb86
movq -0x60(%rbp), %rdi
callq 0xc690
movq %rax, -0x68(%rbp)
jmp 0xbb95
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0xc520
movq %rax, -0x70(%rbp)
jmp 0xbba7
movq -0x70(%rbp), %rdi
leaq 0x3245(%rip), %rsi      # 0xedf7
callq 0xc640
movq %rax, -0x78(%rbp)
jmp 0xbbbd
movq -0x78(%rbp), %rdx
movq -0x68(%rbp), %rsi
leaq 0x3217(%rip), %rdi      # 0xede3
xorl %eax, %eax
callq 0x3050
jmp 0xbbd5
jmp 0xbbd7
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xbb52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xd040
jmp 0xbc32
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0xbc14
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xbc16
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xd040
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3270
nop
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinystr.cpp
// Function: TiXmlString::reserve(unsigned long)
void TiXmlString::reserve (size_type cap)
{
	if (cap > capacity())
	{
		TiXmlString tmp;
		tmp.init(length(), cap);
		memcpy(tmp.start(), data(), length());
		swap(tmp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xc100
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jbe 0xbd0f
leaq -0x18(%rbp), %rdi
callq 0x78a0
movq -0x38(%rbp), %rdi
callq 0x7780
movq %rax, -0x40(%rbp)
jmp 0xbc8d
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x86b0
jmp 0xbca0
leaq -0x18(%rbp), %rdi
callq 0x8690
movq %rax, -0x48(%rbp)
jmp 0xbcaf
movq -0x38(%rbp), %rdi
callq 0x8820
movq %rax, -0x50(%rbp)
jmp 0xbcbe
movq -0x38(%rbp), %rdi
callq 0x7780
movq %rax, -0x58(%rbp)
jmp 0xbccd
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x3100
movq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xc120
jmp 0xbced
leaq -0x18(%rbp), %rdi
callq 0x78c0
jmp 0xbd0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x78c0
jmp 0xbd15
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3270
nop
// File: smallmuou[P]tinyhtml/tinystr.cpp
// Function: TiXmlString::assign(char const*, unsigned long)
TiXmlString& TiXmlString::assign(const char* str, size_type len)
{
	size_type cap = capacity();
	if (len > cap || cap > 3*(len + 8))
	{
		TiXmlString tmp;
		tmp.init(len);
		memcpy(tmp.start(), str, len);
		swap(tmp);
	}
	else
	{
		memmove(start(), str, len);
		set_size(len);
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xc100
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0xbd64
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
imulq $0x3, %rcx, %rcx
cmpq %rcx, %rax
jbe 0xbdd1
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x78a0
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8660
jmp 0xbd80
leaq -0x28(%rbp), %rdi
callq 0x8690
movq %rax, -0x50(%rbp)
jmp 0xbd8f
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3100
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc120
jmp 0xbdaf
leaq -0x28(%rbp), %rdi
callq 0x78c0
jmp 0xbdf7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x78c0
jmp 0xbe01
movq -0x40(%rbp), %rdi
callq 0x8690
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3250
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc150
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3270
nopw (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinystr.cpp
// Function: TiXmlString::append(char const*, unsigned long)
TiXmlString& TiXmlString::append(const char* str, size_type len)
{
	size_type newsize = length() + len;
	if (newsize > capacity())
	{
		reserve (newsize + capacity());
	}
	memmove(finish(), str, len);
	set_size(newsize);
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x7780
movq -0x30(%rbp), %rdi
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xc100
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jbe 0xbe77
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xc100
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq %rax, %rsi
callq 0xbc40
movq -0x30(%rbp), %rdi
callq 0xc180
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3250
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc150
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinystr.cpp
// Function: operator+(TiXmlString const&, TiXmlString const&)
TiXmlString operator + (const TiXmlString & a, const TiXmlString & b)
{
	TiXmlString tmp;
	tmp.reserve(a.length() + b.length());
	tmp += a;
	tmp += b;
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x78a0
movq -0x10(%rbp), %rdi
callq 0x7780
movq %rax, -0x38(%rbp)
jmp 0xbee7
movq -0x18(%rbp), %rdi
callq 0x7780
movq %rax, -0x50(%rbp)
jmp 0xbef6
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rsi
addq %rax, %rsi
callq 0xbc40
jmp 0xbf0c
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7ce0
jmp 0xbf1b
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7ce0
jmp 0xbf2a
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xbf56
jmp 0xbf4d
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x78c0
jmp 0xbf60
movq -0x48(%rbp), %rdi
callq 0x78c0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinystr.cpp
// Function: operator+(TiXmlString const&, char const*)
TiXmlString operator + (const TiXmlString & a, const char* b)
{
	TiXmlString tmp;
	TiXmlString::size_type b_len = static_cast<TiXmlString::size_type>( strlen(b) );
	tmp.reserve(a.length() + b_len);
	tmp += a;
	tmp.append(b, b_len);
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x78a0
movq -0x18(%rbp), %rdi
callq 0x30a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7780
movq %rax, -0x40(%rbp)
jmp 0xbfb4
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rax
addq %rax, %rsi
callq 0xbc40
jmp 0xbfca
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7ce0
jmp 0xbfd9
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xbe10
jmp 0xbfec
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xc018
jmp 0xc00f
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x78c0
jmp 0xc022
movq -0x50(%rbp), %rdi
callq 0x78c0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3270
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinystr.cpp
// Function: operator+(char const*, TiXmlString const&)
TiXmlString operator + (const char* a, const TiXmlString & b)
{
	TiXmlString tmp;
	TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>( strlen(a) );
	tmp.reserve(a_len + b.length());
	tmp.append(a, a_len);
	tmp += b;
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x78a0
movq -0x10(%rbp), %rdi
callq 0x30a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7780
movq %rax, -0x40(%rbp)
jmp 0xc07c
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rsi
addq %rax, %rsi
callq 0xbc40
jmp 0xc092
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xbe10
jmp 0xc0a5
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7ce0
jmp 0xc0b4
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xc0e0
jmp 0xc0d7
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x78c0
jmp 0xc0ea
movq -0x58(%rbp), %rdi
callq 0x78c0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: strtrim(char*)
char* strtrim(char* str) {
    if (!str) return str;

    int len = strlen(str);
    int loff = 0, roff = len-1;
    
    /* Left offset */
    while (loff<len && str[loff]==' ') loff++;
    loff = MIN(loff, roff);

    /* Right offset*/
    while (roff>=0 && str[roff]==' ') roff--;
    roff = MAX(roff, loff);

    len = roff-loff+1;
    strncpy(str, str+loff, roff-loff+1);
    str[len] = '\0';
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc1c0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc2be
movq -0x10(%rbp), %rdi
callq 0x30a0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x1d(%rbp)
jge 0xc1fe
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xc207
jmp 0xc212
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc1dc
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0xc222
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xc228
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x25(%rbp)
jl 0xc24e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xc257
jmp 0xc262
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc22e
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0xc272
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0xc278
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x30c0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlResult::~TiHtmlResult()
TiHtmlResult::~TiHtmlResult() {
    if (elements) {

        while (count > 0)  delete(elements[--count]);

        free(elements);
        elements = NULL;
        capacity = 0;
        count = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x7a1d(%rip), %rcx      # 0x13d68
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0xc3be
jmp 0xc35b
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0xc397
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rax
movl 0x14(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xc395
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x3140
jmp 0xc35b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3190
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlResult::Append(TiHtmlElement*)
bool TiHtmlResult::Append( TiHtmlElement* element ) {
    if (capacity <= 0 || !element) return false;

    if (count >= capacity) {
        elements = (TiHtmlElement** )realloc(elements, capacity*2*sizeof(TiHtmlElement* ));
        if (elements) capacity = capacity*2;
    }
    
    elements[count++] = element;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x10(%rax)
jle 0xc425
cmpq $0x0, -0x18(%rbp)
jne 0xc42b
movb $0x0, -0x1(%rbp)
jmp 0xc492
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %eax
cmpl 0x10(%rcx), %eax
jl 0xc470
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x10(%rax), %eax
shll %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x3260
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0xc46e
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
shll %ecx
movl %ecx, 0x10(%rax)
jmp 0xc470
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq 0x8(%rsi), %rax
movl 0x14(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x14(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlResult::Append(TiHtmlResult*)
bool TiHtmlResult::Append( TiHtmlResult* result ) {
    int count = result->Count();
    int i = 0;
    while (i < count) {
        Append(result->Element(i++));
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc500
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xc4f5
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
callq 0xc520
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xc400
jmp 0xc4cb
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlResult::Clear()
void TiHtmlResult::Clear() {
    if (elements) {
        while (count > 0) delete(elements[--count]);

        memset(elements, 0, sizeof(TiHtmlElement* )*capacity);
        count = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xc5eb
jmp 0xc58d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0xc5c9
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rax
movl 0x14(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xc5c7
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x3140
jmp 0xc58d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlDocument::ParseData(char const*)
bool TiHtmlDocument::ParseData( const char * data ) {
    if (data){ 
        TiXmlDocument* doc = (TiXmlDocument* )internal;
        doc->Parse(data);
        if (doc->Error()) return false;
        return true;
    }
    
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd02a
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %edx
xorl %ecx, %ecx
callq *0x18(%rax)
movq -0x20(%rbp), %rdi
callq 0x7c70
testb $0x1, %al
jne 0xd01e
jmp 0xd024
movb $0x0, -0x1(%rbp)
jmp 0xd02e
movb $0x1, -0x1(%rbp)
jmp 0xd02e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)