LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::Insertar(TPoro const&)
bool TAVLPoro::Insertar(const TPoro &poro) {
	TNodoAVL *nuevo = new TNodoAVL();
	nuevo->item = poro;
	if(EsVacio())
	{
		raiz = nuevo;
		return true;
	}
	else if(FiltraVolumen(poro.Volumen()))
	{
		//Insertar donde toque
		BuscaInserta(nuevo);
		//Calcular el factor de equilibrio de todo el arbol y reordenar
		Reordenar();
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x60, %edi
callq 0x10e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0xa8d0
jmp 0xb5a3
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x5150
movq -0x40(%rbp), %rdi
callq 0xab20
testb $0x1, %al
jne 0xb5c7
jmp 0xb5f4
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0xb639
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x60, %esi
callq 0x10f0
jmp 0xb644
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x40(%rbp), %rdi
cvttsd2si %xmm0, %eax
movl %eax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xb090
testb $0x1, %al
jne 0xb617
jmp 0xb633
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb180
movq -0x40(%rbp), %rdi
callq 0xb370
movb $0x1, -0x1(%rbp)
jmp 0xb639
jmp 0xb635
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1180
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::BuscarAux(TPoro const&) const
bool TAVLPoro::BuscarAux(const TPoro &poro) const
{
	if(raiz->item == poro)
		return true;
	else if(poro.Volumen() < raiz->item.Volumen() && !raiz->iz.EsVacio())
		raiz->iz.Buscar(poro);
	else if(poro.Volumen() > raiz->item.Volumen() && !raiz->de.EsVacio())
		raiz->de.Buscar(poro);
	else
		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, -0x20(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5190
testb $0x1, %al
jne 0xb67a
jmp 0xb683
movb $0x1, -0x1(%rbp)
jmp 0xb730
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rdi
callq 0x5430
movsd -0x28(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xb6d2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xab20
testb $0x1, %al
jne 0xb6d2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0xaf90
jmp 0xb72c
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movq (%rax), %rdi
callq 0x5430
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb724
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0xab20
testb $0x1, %al
jne 0xb724
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0xaf90
jmp 0xb72a
movb $0x0, -0x1(%rbp)
jmp 0xb730
jmp 0xb72c
jmp 0xb72e
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::NodosHoja() const
int TAVLPoro::NodosHoja() const{
	int a1=0;
	if(!EsVacio())
	{
		a1 = a1 + raiz->iz.NodosHoja() + raiz->de.NodosHoja();
		if(EsHoja())
			a1++;
	}
	return a1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
callq 0xab20
testb $0x1, %al
jne 0xb828
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xb7b0
movl -0x20(%rbp), %ecx
movl %eax, %edx
movq -0x18(%rbp), %rax
addl %edx, %ecx
movl %ecx, -0x1c(%rbp)
movq (%rax), %rdi
addq $0x38, %rdi
callq 0xb7b0
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
callq 0xb840
testb $0x1, %al
jne 0xb81d
jmp 0xb826
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb828
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::Postorden() const
TVectorPoro TAVLPoro::Postorden() const {
	//Posición en el vector que almacena el recorrido
	int posicion = 1;
	//Vector del tamaño adecuado para almacenar todos los nodos
	TVectorPoro v(Nodos());
	PostordenAux(v, posicion);
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x1, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xb040
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x5660
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0xaca0
jmp 0xba01
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xba2d
jmp 0xba24
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5970
jmp 0xba37
movq -0x30(%rbp), %rdi
callq 0x5970
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::SustituyeMayorIzq()
void TAVLPoro::SustituyeMayorIzq() {
	TNodoAVL *mayorIzq = raiz;
	TNodoAVL *aux = raiz; //apoyo para intercambiar los valores de los nodos
	if(!raiz->iz.EsVacio())
	{
		//moverse 1 a la izq y todo a la derecha hasta que esté vacío
		mayorIzq = raiz->iz.raiz;
		while(!mayorIzq->de.EsVacio())
			mayorIzq = mayorIzq->de.raiz;
		raiz->item = mayorIzq->item;
		raiz->iz.Borrar(mayorIzq->item); //Borra en este subarbol el mayor de la izquierda que acaba de ser sustituido
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xab20
testb $0x1, %al
jne 0xbac8
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0xab20
xorb $-0x1, %al
testb $0x1, %al
jne 0xba96
jmp 0xbaa4
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xba81
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rsi
movq (%rax), %rdi
callq 0x5150
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0xbad0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::Borrar(TPoro const&)
bool TAVLPoro::Borrar(const TPoro &poro) {
	if(BorrarAB(poro))
	{
		if(!EsVacio())
			Reordenar();
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0xbc20
testb $0x1, %al
jne 0xbaf7
jmp 0xbb13
movq -0x20(%rbp), %rdi
callq 0xab20
testb $0x1, %al
jne 0xbb0d
movq -0x20(%rbp), %rdi
callq 0xb370
movb $0x1, -0x1(%rbp)
jmp 0xbb17
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::SustituyePorHijo()
void TAVLPoro::SustituyePorHijo() {
	TAVLPoro aux;
	if(EsHoja())
		(*this).~TAVLPoro();
	else if(!raiz->iz.EsVacio())
	{
		//sustituir por el hijo izquierdo
		aux = raiz->iz;
		(*this) = aux;
	}
	else if(!raiz->de.EsVacio())
	{
		//sustituir por el hijo derecho
		aux = raiz->de;
		(*this) = aux;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xad30
movq -0x40(%rbp), %rdi
callq 0xb840
movb %al, -0x35(%rbp)
jmp 0xbb5b
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0xbb64
jmp 0xbb8c
movq -0x40(%rbp), %rdi
callq 0xaec0
jmp 0xbc06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xaec0
jmp 0xbc15
movq -0x40(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xab20
testb $0x1, %al
jne 0xbbc7
movq -0x40(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
leaq -0x28(%rbp), %rdi
callq 0xab40
jmp 0xbbb6
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xab40
jmp 0xbbc5
jmp 0xbc04
movq -0x40(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0xab20
testb $0x1, %al
jne 0xbc02
movq -0x40(%rbp), %rax
movq (%rax), %rsi
addq $0x38, %rsi
leaq -0x28(%rbp), %rdi
callq 0xab40
jmp 0xbbf1
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xab40
jmp 0xbc00
jmp 0xbc02
jmp 0xbc04
jmp 0xbc06
leaq -0x28(%rbp), %rdi
callq 0xaec0
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1180
nop
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::BorrarAB(TPoro const&)
bool TAVLPoro::BorrarAB(const TPoro &poro) {
	if(!EsVacio() && Buscar(poro))
	{
		if(raiz->item == poro)
		{
			if(EsHoja() || raiz->iz.EsVacio() || raiz->de.EsVacio())
			{
				//El nodo es sustituido por el hijo
				SustituyePorHijo();
				return true;
			}
			else
			{
				SustituyeMayorIzq();
				return true;
			}
		}
		else if(poro.Volumen() < raiz->item.Volumen() && !raiz->iz.EsVacio())
		raiz->iz.Borrar(poro);
		else if(poro.Volumen() > raiz->item.Volumen() && !raiz->de.EsVacio())
		raiz->de.Borrar(poro);
	}
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xab20
testb $0x1, %al
jne 0xbd71
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaf90
testb $0x1, %al
jne 0xbc5b
jmp 0xbd71
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5190
testb $0x1, %al
jne 0xbc71
jmp 0xbccc
movq -0x20(%rbp), %rdi
callq 0xb840
testb $0x1, %al
jne 0xbca8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xab20
testb $0x1, %al
jne 0xbca8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0xab20
testb $0x1, %al
jne 0xbca8
jmp 0xbcba
movq -0x20(%rbp), %rdi
callq 0xbb30
movb $0x1, -0x1(%rbp)
jmp 0xbd79
movq -0x20(%rbp), %rdi
callq 0xba40
movb $0x1, -0x1(%rbp)
jmp 0xbd79
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rdi
callq 0x5430
movsd -0x28(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xbd1b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xab20
testb $0x1, %al
jne 0xbd1b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0xbad0
jmp 0xbd6d
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movq (%rax), %rdi
callq 0x5430
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xbd6b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0xab20
testb $0x1, %al
jne 0xbd6b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0xbad0
jmp 0xbd6d
jmp 0xbd6f
jmp 0xbd77
movb $0x0, -0x1(%rbp)
jmp 0xbd79
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::Raiz() const
TPoro TAVLPoro::Raiz() const {
	if(!EsVacio())
		return raiz->item;
	else
		return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xab20
testb $0x1, %al
jne 0xbdce
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x5020
jmp 0xbddf
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x5020
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLNode::GetChildren(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<CXMLNode *> CXMLNode::GetChildren(const std::string& strName)
{
	std::vector<CXMLNode *> vecNode;
	for (unsigned int uiCount = 0; uiCount < m_vecChildren.size(); ++uiCount) {
		if (strName == m_vecChildren[uiCount]->GetName()) {
			vecNode.push_back(m_vecChildren[uiCount]);
		}
	}
	return vecNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7660
movl $0x0, -0x20(%rbp)
movq -0x58(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x70(%rbp)
addq $0x78, %rdi
callq 0x7900
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x67b1
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x78, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x79b0
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x65d0
jmp 0x6746
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7920
movb %al, -0x79(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5240
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x6768
jmp 0x67a1
movq -0x58(%rbp), %rdi
addq $0x78, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x79b0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x77e0
jmp 0x6788
jmp 0x67a1
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x7680
jmp 0x67d1
jmp 0x67a3
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x66fa
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x67c4
movq -0x68(%rbp), %rdi
callq 0x7680
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5740
nopw (%rax,%rax)
// File: fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLNode::PrintNode(CXMLNode*, unsigned int const&)
void CXMLNode::PrintNode(CXMLNode* pstNode, const unsigned int& uiLevel)
{
	for (unsigned int uiCount = 0; uiCount < uiLevel << 1; ++uiCount) {
		printf("-");
	}
	printf("%s", pstNode->GetName().c_str());
	std::vector<CXMLNode *> vecChildren = pstNode->GetChildren();
	if (vecChildren.empty()) {
		printf(" %s\n", pstNode->GetValue().c_str());
	} else {
		printf("\n");
		for (unsigned int uiCount = 0; uiCount < vecChildren.size(); ++uiCount) {
			PrintNode(vecChildren[uiCount], uiLevel + 1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jae 0x6861
leaq 0x307be(%rip), %rdi     # 0x3700d
movb $0x0, %al
callq 0x5060
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6839
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x65d0
movq -0xa0(%rbp), %rdi
callq 0x5170
movq %rax, %rsi
leaq 0x30784(%rip), %rdi     # 0x3700f
xorl %eax, %eax
callq 0x5060
jmp 0x6894
leaq -0x40(%rbp), %rdi
callq 0x5240
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x79d0
leaq -0x68(%rbp), %rdi
callq 0x7a00
testb $0x1, %al
jne 0x68bc
jmp 0x6946
movq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x6600
jmp 0x68ce
leaq -0x88(%rbp), %rdi
callq 0x5170
movq %rax, %rsi
leaq 0x3072e(%rip), %rdi     # 0x37012
xorl %eax, %eax
callq 0x5060
jmp 0x68ed
leaq -0x88(%rbp), %rdi
callq 0x5240
jmp 0x69d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5240
jmp 0x69ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x69e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5240
jmp 0x69e3
leaq 0x314bb(%rip), %rdi     # 0x37e08
xorl %eax, %eax
callq 0x5060
jmp 0x6956
movl $0x0, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movq %rax, -0xa8(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x7900
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x69cf
movl -0x8c(%rbp), %eax
movl %eax, %esi
leaq -0x68(%rbp), %rdi
callq 0x79b0
movq -0x98(%rbp), %rdi
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
incl %eax
movl %eax, -0x90(%rbp)
leaq -0x90(%rbp), %rdx
callq 0x6810
jmp 0x69bc
jmp 0x69be
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x6960
jmp 0x69d1
leaq -0x68(%rbp), %rdi
callq 0x7680
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x7680
movq -0x48(%rbp), %rdi
callq 0x5740
nopw %cs:(%rax,%rax)
// File: fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLTree::Create(char const*)
bool CXMLTree::Create(const char* pszPath)
{
	xmlDocPtr pstDoc = xmlParseFile(pszPath);
	if (pstDoc != NULL) {
		xmlNodePtr pstRoot = xmlDocGetRootElement(pstDoc);
		if (pstRoot != NULL) {
			ParseNode(pstRoot, (char *)(pstRoot->name));
		}
		xmlFreeDoc(pstDoc);
	} else {
		return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5700
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6baf
movq -0x20(%rbp), %rdi
callq 0x5610
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6ba4
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5750
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x7a40
jmp 0x6b4b
movq -0x80(%rbp), %rsi
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x48(%rbp), %rdx
callq 0x6bd0
jmp 0x6b62
leaq -0x48(%rbp), %rdi
callq 0x5240
leaq -0x49(%rbp), %rdi
callq 0x5460
jmp 0x6ba4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x6b99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5240
leaq -0x49(%rbp), %rdi
callq 0x5460
jmp 0x6bc7
movq -0x20(%rbp), %rdi
callq 0x57a0
jmp 0x6bb5
movb $0x0, -0x1(%rbp)
jmp 0x6bb9
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5740
// File: fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLTree::GetNodeName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string CXMLTree::GetNodeName(const std::string& strPath)
{
	size_t sizeStart = strPath.find_first_not_of('/');
	if (sizeStart == std::string::npos) {
		return std::string();
	}

	size_t sizeEnd = strPath.find_first_of('/', sizeStart);
	if (sizeEnd == std::string::npos) {
		sizeEnd = strPath.length();
	}
	return strPath.substr(sizeStart, sizeEnd - sizeStart);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x5350
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x7467
movq -0x38(%rbp), %rdi
callq 0x5570
jmp 0x74aa
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x2f, %esi
callq 0x5250
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x7491
movq -0x18(%rbp), %rdi
callq 0x55f0
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x20(%rbp), %rcx
callq 0x5420
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLTree::IsLastName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool CXMLTree::IsLastName(const std::string& strName, const std::string& strPath)
{
	size_t sizePos = strPath.find(strName);
	if (sizePos == std::string::npos) {
		return false;
	} else {
		sizePos += strName.length();
		while (sizePos < strPath.length()) {
			if (strPath[sizePos] != '/') {
				break;
			}
			++ sizePos;
		}
	}
	return sizePos == strPath.length();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5830
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x74f6
movb $0x0, -0x1(%rbp)
jmp 0x756e
movq -0x18(%rbp), %rdi
callq 0x55f0
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x55f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x7549
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5490
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x753b
jmp 0x7549
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7507
jmp 0x754b
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x55f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLTree::FreeNode(CXMLNode*)
void CXMLTree::FreeNode(CXMLNode* pCNode)
{
	std::vector<CXMLNode *> vecNode = pCNode->GetChildren();
	for (unsigned int uiCount = 0; uiCount < vecNode.size(); ++uiCount) {
		FreeNode(vecNode[uiCount]);
	}
	delete pCNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x79d0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7900
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x7608
movl -0x2c(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x79b0
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x7580
jmp 0x75e4
jmp 0x75e6
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x75ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7680
jmp 0x762f
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x7620
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x28(%rbp), %rdi
callq 0x7680
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5740
nopl (%rax,%rax)
// File: fffrankkk[P]XmlCode/src/XMLParser.cpp
// Function: CXMLParser::ParseAttribute(CXMLNode*, CClassDetail*)
void CXMLParser::ParseAttribute(CXMLNode* pCNode, CClassDetail* pCDetail)
{
    BT_AUTO(mapAttribute, pCNode->GetAttribute());
    const string& strName = pCNode->GetName();
    for (BT_AUTO(iterAttr, mapAttribute.begin()); iterAttr != mapAttribute.end(); ++iterAttr) {
        const string& strAttr = iterAttr->first;
        pCDetail->AddAttribute(strName + NUtility::First2Up(strAttr), strAttr);
        //pCDetail->AddAttribute(strName, strAttr);

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xbc50
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x65d0
jmp 0xb263
leaq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xbc80
movq %rax, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x78b0
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x7880
testb $0x1, %al
jne 0xb2a7
jmp 0xb396
leaq -0x88(%rbp), %rdi
callq 0x78e0
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x98(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0xfaf0
jmp 0xb2e5
movq -0xe0(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
leaq -0xd8(%rbp), %rdx
callq 0xbcb0
jmp 0xb301
movq -0xe8(%rbp), %rdi
movq -0x98(%rbp), %rdx
leaq -0xb8(%rbp), %rsi
callq 0x1ada0
jmp 0xb31d
leaq -0xb8(%rbp), %rdi
callq 0x5240
leaq -0xd8(%rbp), %rdi
callq 0x5240
leaq -0x88(%rbp), %rdi
callq 0x9740
jmp 0xb27b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xb3ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xb3b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xb388
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x5240
leaq -0xd8(%rbp), %rdi
callq 0x5240
jmp 0xb3b1
leaq -0x70(%rbp), %rdi
callq 0x5240
leaq -0x48(%rbp), %rdi
callq 0x76e0
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x70(%rbp), %rdi
callq 0x5240
leaq -0x48(%rbp), %rdi
callq 0x76e0
movq -0x78(%rbp), %rdi
callq 0x5740
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/Utility.cpp
// Function: NUtility::Daemonize()
void Daemonize()
{
	if (fork() != 0) {
		exit(0);
	}
	setsid();
	int iFd = -1;
	if ((iFd = open("/dev/null", O_RDWR, 0)) != -1) {
		dup2(iFd, STDIN_FILENO);
		dup2(iFd, STDOUT_FILENO);
		dup2(iFd, STDERR_FILENO);
		if (iFd > STDERR_FILENO) {
			close(iFd);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x5100
cmpl $0x0, %eax
je 0xfa09
xorl %edi, %edi
callq 0x54f0
callq 0x54a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x276f6(%rip), %rdi     # 0x37112
movl $0x2, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x52d0
movl %eax, -0x4(%rbp)
cmpl $-0x1, %eax
je 0xfa66
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0x5390
movl -0x4(%rbp), %edi
movl $0x1, %esi
callq 0x5390
movl -0x4(%rbp), %edi
movl $0x2, %esi
callq 0x5390
cmpl $0x2, -0x4(%rbp)
jle 0xfa64
movl -0x4(%rbp), %edi
callq 0x5800
jmp 0xfa66
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/Utility.cpp
// Function: NUtility::EnableCoreFile()
void EnableCoreFile()
{
	struct rlimit stLimit = {0, 0};
	if (getrlimit(RLIMIT_CORE, &stLimit) == 0) {
		stLimit.rlim_cur = RLIM_INFINITY;
		setrlimit(RLIMIT_CORE, &stLimit);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5200
movl $0x4, %edi
leaq -0x10(%rbp), %rsi
callq 0x5590
cmpl $0x0, %eax
jne 0xfab1
movq $-0x1, -0x10(%rbp)
movl $0x4, %edi
leaq -0x10(%rbp), %rsi
callq 0x5370
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: fffrankkk[P]XmlCode/src/Option.cpp
// Function: COption::SetLongOpt(char const*, int const&, int*, int const&)
void COption::SetLongOpt(const char* pszName, const int& iArg, int* piFlag, const int& iVal)
{
	if (m_uiOptNum < OPT_MAXNUM) {
		m_stLongOpt[m_uiOptNum].name = pszName;
		m_stLongOpt[m_uiOptNum].has_arg = iArg;
		m_stLongOpt[m_uiOptNum].flag = piFlag;
		m_stLongOpt[m_uiOptNum].val = iVal;
		++m_uiOptNum;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x20, 0x408(%rax)
jae 0xfcf1
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdx
movq %rax, %rcx
addq $0x8, %rcx
movl 0x408(%rax), %esi
shlq $0x5, %rsi
addq %rsi, %rcx
movq %rdx, (%rcx)
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
movq %rax, %rcx
addq $0x8, %rcx
movl 0x408(%rax), %esi
shlq $0x5, %rsi
addq %rsi, %rcx
movl %edx, 0x8(%rcx)
movq -0x20(%rbp), %rdx
movq %rax, %rcx
addq $0x8, %rcx
movl 0x408(%rax), %esi
shlq $0x5, %rsi
addq %rsi, %rcx
movq %rdx, 0x10(%rcx)
movq -0x28(%rbp), %rcx
movl (%rcx), %edx
movq %rax, %rcx
addq $0x8, %rcx
movl 0x408(%rax), %esi
shlq $0x5, %rsi
addq %rsi, %rcx
movl %edx, 0x18(%rcx)
movl 0x408(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x408(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fffrankkk[P]XmlCode/src/Main.cpp
// Function: CMain::Core(tagOption*)
void CMain::Core(OPTION_S* pstOpt)
{
    CXMLParser CParser;
    BT_AUTO(vecDetail, CParser.Parse(pstOpt->m_szXMLFile));
    CClassDetail* pCRoot = CParser.ParseRoot(pstOpt->m_szXMLFile);
//    PrintDetail(vecDetail);
    Inc(vecDetail, pCRoot);
    Src(vecDetail, pCRoot);

/*
    for (BT_AUTO(iterDetail, vecDetail.begin()); iterDetail != vecDetail.end(); ++iterDetail) {
        //PrintDetail(*iterDetail, 1);
        vector<string> vecDeclare = (*iterDetail)->GenerateGet("CConfig");
        for (size_t zuCount = 0; zuCount < vecDeclare.size(); ++zuCount) {
            cout << vecDeclare[zuCount] << endl;
        }
    }

    //vector<string> vecDeclare = CCfgDetail.GenerateDeclare();
    vector<string> vecDeclare = CCfgDetail.GenerateGet();
    for (size_t zuCount = 0; zuCount < vecDeclare.size(); ++zuCount) {
        cout << vecDeclare[zuCount] << endl;
    }

*/

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xa240
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
leaq -0x30(%rbp), %rdi
callq 0xa2a0
jmp 0x108dc
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
leaq -0x18(%rbp), %rdi
callq 0xa9b0
movq %rax, -0x60(%rbp)
jmp 0x108f3
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0x10970
jmp 0x1090e
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0x11700
jmp 0x10921
leaq -0x30(%rbp), %rdi
callq 0xbbf0
leaq -0x18(%rbp), %rdi
callq 0xa260
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1095c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbbf0
leaq -0x18(%rbp), %rdi
callq 0xa260
movq -0x38(%rbp), %rdi
callq 0x5740
nop
// File: fffrankkk[P]XmlCode/src/Main.cpp
// Function: CMain::PrintDetail(CClassDetail*, int const&)
void CMain::PrintDetail(CClassDetail* pCDetail, const int& iLevel)
{
    for (int iCount = 0; iCount < iLevel; ++iCount) {
        printf("-");
    }
    printf("\n");
    pCDetail->Print();
    vector<CClassDetail *> vecChildren = pCDetail->GetChildren();
    for (size_t zuCount = 0; zuCount < vecChildren.size(); ++zuCount) {
        PrintDetail(vecChildren[zuCount], iLevel + 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x12377
leaq 0x24ca8(%rip), %rdi     # 0x3700d
movb $0x0, %al
callq 0x5060
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12353
leaq 0x25a8a(%rip), %rdi     # 0x37e08
movb $0x0, %al
callq 0x5060
movq -0x10(%rbp), %rdi
callq 0x26010
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1b330
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe7c0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x12411
movq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x12900
movq -0x60(%rbp), %rdi
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
incl %eax
movl %eax, -0x44(%rbp)
leaq -0x44(%rbp), %rdx
callq 0x12330
jmp 0x123ea
jmp 0x123ec
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x123a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbbf0
jmp 0x12420
leaq -0x38(%rbp), %rdi
callq 0xbbf0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5740
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/Dir.cpp
// Function: CDir::Read(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool CDir::Read(std::vector<std::string>& CFileName)
{
	struct dirent stEntry;
	struct dirent* pstResult = NULL;
	int iRet = readdir_r(m_pstDir, &stEntry, &pstResult);
	while (pstResult != NULL) {
		if (iRet != 0) {
			return false;
		}
		if (strcmp(stEntry.d_name, ".") != 0 && strcmp(stEntry.d_name, "..") != 0) {
			CFileName.push_back(std::string(stEntry.d_name));
		}
		iRet = readdir_r(m_pstDir, &stEntry, &pstResult);
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x180(%rbp)
movq $0x0, -0x138(%rbp)
movq 0x8(%rax), %rdi
leaq -0x130(%rbp), %rsi
leaq -0x138(%rbp), %rdx
callq 0x5130
movl %eax, -0x13c(%rbp)
cmpq $0x0, -0x138(%rbp)
je 0x151f6
cmpl $0x0, -0x13c(%rbp)
je 0x150d6
movb $0x0, -0x1(%rbp)
jmp 0x151fa
leaq -0x130(%rbp), %rdi
addq $0x13, %rdi
leaq 0x22168(%rip), %rsi     # 0x37250
callq 0x5580
cmpl $0x0, %eax
je 0x151cd
leaq -0x130(%rbp), %rdi
addq $0x13, %rdi
leaq 0x22147(%rip), %rsi     # 0x3724f
callq 0x5580
cmpl $0x0, %eax
je 0x151cd
movq -0x18(%rbp), %rax
movq %rax, -0x198(%rbp)
leaq -0x11d(%rbp), %rax
movq %rax, -0x190(%rbp)
leaq -0x161(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0x5750
movq -0x190(%rbp), %rsi
movq -0x188(%rbp), %rdx
leaq -0x160(%rbp), %rdi
callq 0x7a40
jmp 0x1515e
movq -0x198(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x15500
jmp 0x15173
leaq -0x160(%rbp), %rdi
callq 0x5240
leaq -0x161(%rbp), %rdi
callq 0x5460
jmp 0x151cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x170(%rbp)
movl %eax, -0x174(%rbp)
jmp 0x151bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x170(%rbp)
movl %eax, -0x174(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x5240
leaq -0x161(%rbp), %rdi
callq 0x5460
jmp 0x15208
movq -0x180(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x130(%rbp), %rsi
leaq -0x138(%rbp), %rdx
callq 0x5130
movl %eax, -0x13c(%rbp)
jmp 0x150b6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq -0x170(%rbp), %rdi
callq 0x5740
nopw %cs:(%rax,%rax)
// File: fffrankkk[P]XmlCode/src/Dir.cpp
// Function: CDir::Remove(char const*)
void CDir::Remove(const char* pszDir)
{
	//check directory
	if (IsDir(pszDir)) {
		CDir CDirReader;
	    if (!CDirReader.Open(pszDir)) {
	        return;
		}

		std::vector<std::string> CFileName;
		CDirReader.Read(CFileName);
		for (unsigned int uiCount = 0; uiCount < CFileName.size(); ++uiCount){
			CFileName[uiCount] = "/" + CFileName[uiCount];
			CFileName[uiCount] = pszDir + CFileName[uiCount];
			Remove(CFileName[uiCount].c_str());
	    }
		CDirReader.Close();
	}
	remove(pszDir);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15250
testb $0x1, %al
jne 0x152c1
jmp 0x154a9
leaq -0x18(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x14f30
movq -0x98(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x14ff0
movb %al, -0x89(%rbp)
jmp 0x152e9
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x15312
jmp 0x152f5
movl $0x1, -0x28(%rbp)
jmp 0x15488
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1549e
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x15530
movq -0xa0(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x15070
jmp 0x15334
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq %rax, -0xa8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12a30
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x1546d
movl -0x44(%rbp), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0x12a50
movq %rax, %rdx
leaq 0x222d7(%rip), %rsi     # 0x37650
leaq -0x68(%rbp), %rdi
callq 0x15550
jmp 0x15384
movl -0x44(%rbp), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x12a50
movq %rax, %rdi
leaq -0x68(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
callq 0x5500
movq -0xc0(%rbp), %rdi
callq 0x5240
movq -0xb8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %esi
callq 0x12a50
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
leaq -0x88(%rbp), %rdi
callq 0x15550
jmp 0x153ec
movl -0x44(%rbp), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x12a50
movq %rax, %rdi
leaq -0x88(%rbp), %rsi
movq %rsi, -0xd0(%rbp)
callq 0x5500
movq -0xd0(%rbp), %rdi
callq 0x5240
movq -0xc8(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, %esi
callq 0x12a50
movq %rax, %rdi
callq 0x5170
movq %rax, %rdi
callq 0x152a0
jmp 0x15446
jmp 0x15448
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1533b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12a70
jmp 0x1549e
leaq -0x18(%rbp), %rdi
callq 0x15030
jmp 0x15478
leaq -0x40(%rbp), %rdi
callq 0x12a70
movl $0x0, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x14f60
movl -0x28(%rbp), %eax
testl %eax, %eax
je 0x1549c
jmp 0x1549a
jmp 0x154b2
jmp 0x154a9
leaq -0x18(%rbp), %rdi
callq 0x14f60
jmp 0x154bb
movq -0x8(%rbp), %rdi
callq 0x5770
addq $0xd0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5740
nopw %cs:(%rax,%rax)
// File: fffrankkk[P]XmlCode/src/ClassPara.cpp
// Function: CClassPara::Parse(CLASS_S const*)
void CClassPara::Parse(const CLASS_S* pstOpt)
{
    m_strParaName = m_strName = pstOpt->m_szName;
    m_strName[0] = toupper(m_strName[0]);
    vector<string> vecMem;
    string strText = pstOpt->m_szMember;
    BT_Split(vecMem, strText, stMem);
    for_each(vecMem.begin(), vecMem.end(), TYPESEP_S(m_vecMember));
//    for_each(m_vecMember.begin(), m_vecMember.end(), stPrint);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5560
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
addq $0x28, %rdi
callq 0x5050
movq -0xa8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xa0(%rbp)
callq 0x5820
movsbl (%rax), %edi
callq 0x5790
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movb %al, -0x91(%rbp)
callq 0x5820
movb -0x91(%rbp), %cl
movb %cl, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x15530
movq -0x10(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x90(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5750
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x7a40
jmp 0x16168
leaq -0x49(%rbp), %rdi
callq 0x5460
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x1, %edx
callq 0x16610
jmp 0x16185
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x15b00
movq -0xb8(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x15940
movq -0xb0(%rbp), %rsi
movq %rax, -0x70(%rbp)
addq $0x48, %rsi
leaq -0x78(%rbp), %rdi
callq 0x166f0
jmp 0x161bf
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x16650
movq %rax, -0xc0(%rbp)
jmp 0x161d9
movq -0xc0(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5240
leaq -0x28(%rbp), %rdi
callq 0x12a70
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x5460
jmp 0x1622b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5240
leaq -0x28(%rbp), %rdi
callq 0x12a70
movq -0x58(%rbp), %rdi
callq 0x5740
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/ClassPara.cpp
// Function: CClassPara::GetIncDir[abi:cxx11]()
string CClassPara::GetIncDir()
{
    if (CDir::Exist("./inc/") && CDir::Exist("./src/")) {
        return string("./inc/");
    } else if (CDir::Exist("../inc/") && CDir::Exist("../src/")) {
        return string("../inc/");
    }
    return string("./");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x21007(%rip), %rdi     # 0x37269
callq 0x15220
testb $0x1, %al
jne 0x1626d
jmp 0x162ca
leaq 0x20ffd(%rip), %rdi     # 0x37271
callq 0x15220
testb $0x1, %al
jne 0x1627f
jmp 0x162ca
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x5750
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x20fce(%rip), %rsi     # 0x37269
callq 0x7a40
jmp 0x162a2
leaq -0x11(%rbp), %rdi
callq 0x5460
jmp 0x1637a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x5460
jmp 0x16384
leaq 0x20f97(%rip), %rdi     # 0x37268
callq 0x15220
testb $0x1, %al
jne 0x162dc
jmp 0x16333
leaq 0x20f8d(%rip), %rdi     # 0x37270
callq 0x15220
testb $0x1, %al
jne 0x162ee
jmp 0x16333
leaq -0x25(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x5750
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x20f5e(%rip), %rsi     # 0x37268
callq 0x7a40
jmp 0x16311
leaq -0x25(%rbp), %rdi
callq 0x5460
jmp 0x1637a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x5460
jmp 0x16384
jmp 0x16335
leaq -0x26(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5750
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x20f27(%rip), %rsi     # 0x37278
callq 0x7a40
jmp 0x16358
leaq -0x26(%rbp), %rdi
callq 0x5460
jmp 0x1637a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x5460
jmp 0x16384
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5740
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/ClassPara.cpp
// Function: CClassPara::GetSrcDir[abi:cxx11]()
string CClassPara::GetSrcDir()
{
    if (CDir::Exist("./src/") && CDir::Exist("./src/")) {
        return string("./src/");
    } else if (CDir::Exist("../inc/") && CDir::Exist("../src/")) {
        return string("../src/");
    }
    return string("./");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x20ebf(%rip), %rdi     # 0x37271
callq 0x15220
testb $0x1, %al
jne 0x163bd
jmp 0x1641a
leaq 0x20ead(%rip), %rdi     # 0x37271
callq 0x15220
testb $0x1, %al
jne 0x163cf
jmp 0x1641a
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x5750
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x20e86(%rip), %rsi     # 0x37271
callq 0x7a40
jmp 0x163f2
leaq -0x11(%rbp), %rdi
callq 0x5460
jmp 0x164ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x5460
jmp 0x164d4
leaq 0x20e47(%rip), %rdi     # 0x37268
callq 0x15220
testb $0x1, %al
jne 0x1642c
jmp 0x16483
leaq 0x20e3d(%rip), %rdi     # 0x37270
callq 0x15220
testb $0x1, %al
jne 0x1643e
jmp 0x16483
leaq -0x25(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x5750
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x20e16(%rip), %rsi     # 0x37270
callq 0x7a40
jmp 0x16461
leaq -0x25(%rbp), %rdi
callq 0x5460
jmp 0x164ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x5460
jmp 0x164d4
jmp 0x16485
leaq -0x26(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5750
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x20dd7(%rip), %rsi     # 0x37278
callq 0x7a40
jmp 0x164a8
leaq -0x26(%rbp), %rdi
callq 0x5460
jmp 0x164ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x5460
jmp 0x164d4
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5740
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/ClassDetail.cpp
// Function: CClassDetail::AddAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CClassDetail::AddAttribute(const string& strName, const string& strAttr)
{
    BT_AUTO(iterMem, m_vecAttr.begin());
    for (; iterMem != m_vecAttr.end() && (*iterMem)->GetName() != strName; ++iterMem);
    if (iterMem == m_vecAttr.end()) {
        CClassMember* pCMem = new CClassMember;
        pCMem->SetName(strName);
        pCMem->SetType("a");
        pCMem->SetAttrName(strAttr);
        m_vecAttr.push_back(pCMem);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
addq $0x60, %rdi
callq 0x261a0
movq %rax, -0x20(%rbp)
movq -0xa0(%rbp), %rdi
addq $0x60, %rdi
callq 0x26210
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x261d0
movb %al, %cl
movb $0x0, -0x49(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa1(%rbp)
jne 0x1ae05
jmp 0x1ae31
leaq -0x20(%rbp), %rdi
callq 0x26270
movq (%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1aae0
movb $0x1, -0x49(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x26240
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
movb %al, -0xa2(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x1ae45
jmp 0x1ae4e
leaq -0x48(%rbp), %rdi
callq 0x5240
movb -0xa2(%rbp), %al
testb $0x1, %al
jne 0x1ae5a
jmp 0x1ae6a
jmp 0x1ae5c
leaq -0x20(%rbp), %rdi
callq 0x26290
jmp 0x1adcf
movq -0xa0(%rbp), %rdi
addq $0x60, %rdi
callq 0x26210
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x262b0
testb $0x1, %al
jne 0x1ae94
jmp 0x1afa7
movl $0x68, %edi
callq 0x53e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
callq 0x1a950
jmp 0x1aeb2
movq -0xb0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1aa80
movq -0x60(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x5750
movq -0xb8(%rbp), %rdx
leaq 0x1c47d(%rip), %rsi     # 0x37373
leaq -0x90(%rbp), %rdi
callq 0x7a40
jmp 0x1af04
movq -0xc0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1aab0
jmp 0x1af19
leaq -0x90(%rbp), %rdi
callq 0x5240
leaq -0x91(%rbp), %rdi
callq 0x5460
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1aa20
movq -0xa0(%rbp), %rdi
addq $0x60, %rdi
leaq -0x60(%rbp), %rsi
callq 0x262f0
jmp 0x1afa7
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x68, %esi
callq 0x53f0
jmp 0x1afb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1af99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5240
leaq -0x91(%rbp), %rdi
callq 0x5460
jmp 0x1afb0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x5740
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/ClassDetail.cpp
// Function: CClassDetail::GetChildren()
vector<CClassDetail *> CClassDetail::GetChildren()
{
    vector<CClassDetail *> vecChildren;
    for (BT_AUTO(iterChild, m_mapChildren.begin()); iterChild != m_mapChildren.end(); ++iterChild) {
        vecChildren.push_back(iterChild->second);
    }
    return vecChildren;
}

// 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 -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xb8f0
movq -0x40(%rbp), %rdi
addq $0x78, %rdi
callq 0x26390
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x78, %rdi
callq 0xba50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x263c0
testb $0x1, %al
jne 0x1b391
jmp 0x1b3d0
leaq -0x20(%rbp), %rdi
callq 0xbb90
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0xbb20
jmp 0x1b3ac
jmp 0x1b3ae
leaq -0x20(%rbp), %rdi
callq 0xdd80
jmp 0x1b36d
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xbbf0
jmp 0x1b3ed
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1b3e3
movq -0x50(%rbp), %rdi
callq 0xbbf0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5740
nopw %cs:(%rax,%rax)
// File: fffrankkk[P]XmlCode/src/ClassDetail.cpp
// Function: CClassDetail::Print()
void CClassDetail::Print()
{
    cout << "node name:"<< m_strName << "\t" << m_strType << endl;
    for (unsigned int uiCount = 0; uiCount < m_vecMem.size(); ++uiCount) {
        m_vecMem[uiCount]->Print();
    }
    for (unsigned int uiCount = 0; uiCount < m_vecAttr.size(); ++uiCount) {
        m_vecAttr[uiCount]->Print();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x24f9d(%rip), %rdi     # 0x4afc8
leaq 0x11b3b(%rip), %rsi     # 0x37b6d
callq 0x53d0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x5340
movq %rax, %rdi
leaq 0x114b8(%rip), %rsi     # 0x37509
callq 0x53d0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rsi
callq 0x5340
movq %rax, %rdi
movq 0x24f40(%rip), %rsi     # 0x4afb0
callq 0x5440
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
addq $0x48, %rdi
callq 0x269b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x260c1
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x269d0
movq (%rax), %rdi
callq 0x1ab40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2607c
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x60, %rdi
callq 0x269b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x2610d
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x269d0
movq (%rax), %rdi
callq 0x1ab40
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x260c8
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)