LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Insertar(TPoro const&)
bool TABBPoro::Insertar(const TPoro &poro) {
	//se crea el nodo a insertar
	TNodoABB *aux = new TNodoABB;;
	aux->item = poro;
	if(EsVacio())
	{
		nodo = aux;
		return true;
	}
	else if(FiltraVolumen(poro.Volumen()))
	{
		BuscaInserta(aux);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
pushq $0x58
popq %rdi
callq 0x10e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x4aac
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3742
cmpq $0x0, (%r14)
je 0x515d
movq %r15, %rdi
callq 0x38de
cvttsd2si %xmm0, %eax
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x4fe8
testb %al, %al
je 0x5164
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5086
jmp 0x5160
movq %rbx, (%r14)
movb $0x1, %al
jmp 0x5166
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x10f0
movq %r14, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Borrar(TPoro const&)
bool TABBPoro::Borrar(const TPoro &poro) {
	if(!EsVacio() && Buscar(poro))
	{
		if(nodo->item == poro)
		{
			if(EsHoja() || nodo->iz.EsVacio() || nodo->de.EsVacio())
			{
				//El nodo es sustituido por el hijo
				SustituyePorHijo();
				return true;
			}
			else
			{
				SustituyeMayorIzq();
				return true;
			}
		}
		else if(poro.Volumen() < nodo->item.Volumen() && !nodo->iz.EsVacio())
		nodo->iz.Borrar(poro);
		else if(poro.Volumen() > nodo->item.Volumen() && !nodo->de.EsVacio())
		nodo->de.Borrar(poro);
	}
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, (%rdi)
je 0x51d2
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4f64
testb %al, %al
je 0x51d2
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3770
testb %al, %al
je 0x51e9
movq (%rbx), %rax
cmpq $0x0, 0x38(%rax)
je 0x51d6
cmpq $0x0, 0x18(%rax)
je 0x51d6
movq %rbx, %rdi
callq 0x52b0
jmp 0x51de
xorl %eax, %eax
jmp 0x51e0
movq %rbx, %rdi
callq 0x5234
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x38de
movsd %xmm0, -0x18(%rbp)
movq (%rbx), %rdi
callq 0x38de
ucomisd -0x18(%rbp), %xmm0
jbe 0x5215
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x5215
addq $0x18, %rdi
jmp 0x522c
movq %r14, %rdi
callq 0x38de
movq (%rbx), %rdi
callq 0x38de
movq (%rbx), %rdi
addq $0x38, %rdi
movq %r14, %rsi
callq 0x5188
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::SustituyePorHijo()
void TABBPoro::SustituyePorHijo()
{
	TABBPoro aux;
	if(EsHoja())
		(*this).~TABBPoro();
	else if(!nodo->iz.EsVacio())
	{
		//sustituir por el hijo izquierdo
		aux = nodo->iz;
		(*this) = aux;
	}
	else if(!nodo->de.EsVacio())
	{
		//sustituir por el hijo derecho
		aux = nodo->de;
		(*this) = aux;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %rdi
callq 0x4e12
movq (%rbx), %rax
leaq 0x18(%rax), %rsi
cmpq $0x0, 0x38(%rax)
movq 0x18(%rax), %rcx
je 0x5268
addq $0x38, %rax
testq %rcx, %rcx
cmoveq %rax, %rsi
jmp 0x526d
testq %rcx, %rcx
je 0x5292
leaq -0x28(%rbp), %rdi
callq 0x4bf0
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x4bf0
leaq -0x28(%rbp), %rdi
callq 0x4ef8
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x4ef8
jmp 0x5282
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x4ef8
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::SustituyeMayorIzq()
void TABBPoro::SustituyeMayorIzq()
{
	TNodoABB *mayorIzq = nodo;
	TNodoABB *aux = nodo; //apoyo para intercambiar los valores de los nodos
	if(!nodo->iz.EsVacio())
	{
		//moverse 1 a la izq y todo a la derecha hasta que esté vacío
		mayorIzq = nodo->iz.nodo;
		while(!mayorIzq->de.EsVacio())
			mayorIzq = mayorIzq->de.nodo;
		nodo->item = mayorIzq->item;
		nodo->iz.Borrar(mayorIzq->item); //Borra en este subarbol el mayor de la izquierda que acaba de ser sustituido
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x52ed
movq %rax, %r14
movq 0x38(%rax), %rax
testq %rax, %rax
jne 0x52c6
movq %r14, %rsi
callq 0x3742
movq (%rbx), %rdi
addq $0x18, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5188
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::BuscarAux(TPoro const&) const
bool TABBPoro::BuscarAux(const TPoro &poro) const
{
	if(nodo->item == poro)
		return true;
	else if(poro.Volumen() < nodo->item.Volumen() && !nodo->iz.EsVacio())
		nodo->iz.Buscar(poro);
	else if(poro.Volumen() > nodo->item.Volumen() && !nodo->de.EsVacio())
		nodo->de.Buscar(poro);
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x3770
movl %eax, %r15d
testb %al, %al
jne 0x5361
movq %rbx, %rdi
callq 0x38de
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x38de
ucomisd -0x20(%rbp), %xmm0
jbe 0x5337
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x536f
movq %rbx, %rdi
callq 0x38de
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x38de
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5361
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x5375
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x18, %rdi
jmp 0x5379
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x4f64
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Raiz() const
TPoro TABBPoro::Raiz() const {
	if(!EsVacio())
		return nodo->item;
	else
		return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
addq $0x8, %rsi
testq %rax, %rax
cmovneq %rax, %rsi
callq 0x36b6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Altura() const
int TABBPoro::Altura() const {
	int a1, a2;
	if(!EsVacio())
	{
		a1 = nodo->iz.Altura();
		a2 = nodo->de.Altura();
		return (1 + (a1<a2 ? a2:a1));
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x53da
leaq 0x18(%rbx), %rdi
callq 0x53a8
movl %eax, %r14d
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x53a8
cmpl %eax, %r14d
cmovgl %r14d, %eax
incl %eax
jmp 0x53dc
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::NodosHoja() const
int TABBPoro::NodosHoja() const {
	int a1=0;
	if(!EsVacio())
	{
		a1 = a1 + nodo->iz.NodosHoja() + nodo->de.NodosHoja();
		if(EsHoja())
			a1++;
	}
	return a1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r15
testq %r15, %r15
je 0x5461
leaq 0x18(%r15), %rbx
movq %rbx, %rdi
callq 0x5424
movl %eax, %r14d
leaq 0x38(%r15), %rdi
callq 0x5424
addl %r14d, %eax
cmpq $0x0, 0x38(%r15)
jne 0x5463
cmpq $0x1, (%rbx)
adcl $0x0, %eax
jmp 0x5463
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Inorden() const
TVectorPoro TABBPoro::Inorden() 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());
	InordenAux(v, posicion);
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1c(%rbp), %r15
movl $0x1, (%r15)
movq %rsi, %rdi
callq 0x4fc0
movq %rbx, %rdi
movl %eax, %esi
callq 0x39da
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4c4c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bb6
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Niveles() const
TVectorPoro TABBPoro::Niveles() const {
	TVectorPoro recorrido;
	if(!EsVacio())
	{
		recorrido.Redimensionar(Nodos());
		int pos = 1;
		NivelesAux(recorrido, pos);
	}

	return recorrido;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x39b8
cmpq $0x0, (%r14)
je 0x55c5
movq %r14, %rdi
callq 0x4fc0
movq %rbx, %rdi
movl %eax, %esi
callq 0x3e42
leaq -0x14(%rbp), %rdx
movl $0x1, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d58
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x55d3
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bb6
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::operator+(TABBPoro const&)
TABBPoro TABBPoro::operator +(const TABBPoro &arbol) {
	TABBPoro aux((*this));
	TVectorPoro vectorArbol(arbol.Inorden());
	for(int i=1; i<=vectorArbol.Longitud(); i++)
		aux.Insertar(vectorArbol[i]);
	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x4e30
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x546e
pushq $0x1
popq %r14
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x3df2
cmpl %eax, %r14d
jg 0x563a
movq %r15, %rdi
movl %r14d, %esi
callq 0x3d6c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x50fe
incl %r14d
jmp 0x5612
leaq -0x40(%rbp), %rdi
callq 0x3bb6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x5662
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3bb6
movq %rbx, %rdi
callq 0x4ef8
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::operator-(TABBPoro const&)
TABBPoro TABBPoro::operator -(const TABBPoro &arbol) {
	TVectorPoro vectorThis = Inorden();
	TABBPoro aux;
	for (int i=1; i<=vectorThis.Longitud(); i++)
	{
		if(!arbol.Buscar(vectorThis[i]))
			aux.Insertar(vectorThis[i]);
	}
	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
callq 0x546e
movq %rbx, %rdi
callq 0x4e12
pushq $0x1
popq %r15
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x3df2
cmpl %eax, %r15d
jg 0x56e2
movq %r12, %rdi
movl %r15d, %esi
callq 0x3d6c
movq %r14, %rdi
movq %rax, %rsi
callq 0x4f64
testb %al, %al
jne 0x56dd
movq %r12, %rdi
movl %r15d, %esi
callq 0x3d6c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x50fe
incl %r15d
jmp 0x56a0
leaq -0x48(%rbp), %rdi
callq 0x3bb6
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x570b
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ef8
leaq -0x48(%rbp), %rdi
callq 0x3bb6
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TNodoAVL::CopiarNodo(TNodoAVL const&)
void TNodoAVL::CopiarNodo(const TNodoAVL &origen) {
	(this)->item = origen.item;
	if(!origen.de.EsVacio())
		(this)->de = origen.de;
	if(!origen.iz.EsVacio())
		(this)->iz = origen.iz;
	fe = origen.fe;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3742
cmpq $0x0, 0x38(%r14)
je 0x5dac
leaq 0x38(%r14), %rsi
leaq 0x38(%rbx), %rdi
callq 0x5e36
cmpq $0x0, 0x18(%r14)
je 0x5dc0
leaq 0x18(%r14), %rsi
leaq 0x18(%rbx), %rdi
callq 0x5e36
movl 0x58(%r14), %eax
movl %eax, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TNodoAVL::operator=(TNodoAVL const&)
TNodoAVL& TNodoAVL::operator =(const TNodoAVL &origen) {
	if(this != &origen)
	{
		(*this).~TNodoAVL();
		CopiarNodo(origen);
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x5e1f
movq %rsi, %r14
movq %rbx, %rdi
callq 0x5dcc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5d86
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::operator=(TAVLPoro const&)
TAVLPoro & TAVLPoro::operator=(const TAVLPoro &origen) {
	if(this != &origen)
	{
		(this)->~TAVLPoro();
		Copiar(origen);
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x5e5b
movq %rsi, %r14
movq %rbx, %rdi
callq 0x607e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f8e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::InordenAux(TVectorPoro&, int&) const
void TAVLPoro::InordenAux(TVectorPoro &vector, int &posicion) const {
	if(!EsVacio())
	{
		raiz->iz.InordenAux(vector, posicion);
		vector[posicion] = raiz->item;
		posicion++;
		raiz->de.InordenAux(vector, posicion);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x5eb2
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5e64
movq (%r15), %r12
movl (%rbx), %esi
movq %r14, %rdi
callq 0x3d6c
movq %rax, %rdi
movq %r12, %rsi
callq 0x3742
incl (%rbx)
movq (%r15), %r15
addq $0x38, %r15
jmp 0x5e78
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::PreordenAux(TVectorPoro&, int&) const
void TAVLPoro::PreordenAux(TVectorPoro &vector, int &posicion) const {
	if(!EsVacio())
	{
		vector[posicion] = raiz->item;
		posicion++;
		raiz->iz.PreordenAux(vector, posicion);
		raiz->de.PreordenAux(vector, posicion);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%r15), %r12
testq %r12, %r12
je 0x5f0a
movl (%rbx), %esi
movq %r14, %rdi
callq 0x3d6c
movq %rax, %rdi
movq %r12, %rsi
callq 0x3742
incl (%rbx)
movq (%r15), %rdi
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5ebc
movq (%r15), %r15
addq $0x38, %r15
jmp 0x5ed0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::PostordenAux(TVectorPoro&, int&) const
void TAVLPoro::PostordenAux(TVectorPoro &vector, int &posicion) const {
	if(!EsVacio())
	{
		raiz->iz.PostordenAux(vector, posicion);
		raiz->de.PostordenAux(vector, posicion);
		vector[posicion] = raiz->item;
		posicion++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5f64
movq %rdx, %rbx
movq %rsi, %r14
addq $0x18, %rdi
callq 0x5f14
movq (%r15), %rdi
addq $0x38, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5f14
movq (%r15), %r15
movl (%rbx), %esi
movq %r14, %rdi
callq 0x3d6c
movq %rax, %rdi
movq %r15, %rsi
callq 0x3742
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::Copiar(TAVLPoro const&)
void TAVLPoro::Copiar(const TAVLPoro &origen){
	if(!origen.EsVacio())
	{
		TNodoAVL *aux = new TNodoAVL();
		aux->item = origen.raiz->item;
		aux->fe = origen.raiz->fe;
		raiz = aux;
		raiz->iz.Copiar(origen.raiz->iz);
		raiz->de.Copiar(origen.raiz->de);
		error = origen.error;
	}
	else
		raiz = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, (%rsi)
je 0x6012
movq %rsi, %rbx
pushq $0x60
popq %rdi
callq 0x10e0
movq %rax, %r15
movq %rax, %rdi
callq 0x5cc0
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x3742
movq (%rbx), %rax
movl 0x58(%rax), %eax
movl %eax, 0x58(%r15)
movq %r15, (%r14)
addq $0x18, %r15
movq (%rbx), %rsi
addq $0x18, %rsi
movq %r15, %rdi
callq 0x5f8e
movq (%r14), %rdi
addq $0x38, %rdi
movq (%rbx), %rsi
addq $0x38, %rsi
callq 0x5f8e
addq $0x8, %rbx
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3742
andq $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r15, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::CompruebaNodos(TAVLPoro const&) const
bool TAVLPoro::CompruebaNodos(const TAVLPoro &otroArbol) const {
	if(EsVacio())
		return true;
	else
	{
		return (otroArbol.Buscar(raiz->item) && raiz->iz.CompruebaNodos(otroArbol) && raiz->de.CompruebaNodos(otroArbol));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %r15
testq %r15, %r15
je 0x60d3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x60e4
testb %al, %al
je 0x60d3
movq (%r14), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
callq 0x6090
testb %al, %al
je 0x60d3
movq (%r14), %r14
addq $0x38, %r14
jmp 0x60a0
testq %r15, %r15
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::Buscar(TPoro const&) const
bool TAVLPoro::Buscar(const TPoro &poro) const {
	if(EsVacio())
		return false;
	else
		return BuscarAux(poro);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, (%rdi)
je 0x60f4
popq %rbp
jmp 0x64d2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::FiltraVolumen(int const&)
bool TAVLPoro::FiltraVolumen(const int &volumen) {
	if(raiz->item.Volumen() == volumen)
		return false;
	else if(volumen < raiz->item.Volumen() && !raiz->iz.EsVacio())
		raiz->iz.FiltraVolumen(volumen);
	else if(volumen > raiz->item.Volumen() && !raiz->de.EsVacio())
		raiz->de.FiltraVolumen(volumen);
	else
		return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x38de
cvtsi2sdl (%rbx), %xmm1
ucomisd %xmm1, %xmm0
jne 0x617f
jnp 0x61cf
movsd %xmm0, -0x28(%rbp)
movq (%r14), %rdi
movsd %xmm1, -0x18(%rbp)
callq 0x38de
ucomisd -0x18(%rbp), %xmm0
movq (%r14), %rdi
jbe 0x61a2
cmpq $0x0, 0x18(%rdi)
jne 0x61e5
cvtsi2sdl (%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x38de
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
jbe 0x61cf
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x61eb
cmpneqsd %xmm1, %xmm0
movq %xmm0, %rax
andl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x18, %rdi
jmp 0x61ef
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x615a
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::BuscaInserta(TNodoAVL*)
void TAVLPoro::BuscaInserta(TNodoAVL *nuevo){
	//Comprobar recursivamente que sea menor o mayor que el elemento nodo de la raiz e introducir donde quepa
	if(nuevo->item.Volumen() < raiz->item.Volumen())
	{
		//recursión hacia la izquierda del árbol
		if(!raiz->iz.EsVacio())
			raiz->iz.BuscaInserta(nuevo);
		else
			raiz->iz.raiz = nuevo;
	}
	else if(nuevo->item.Volumen() > raiz->item.Volumen())
	{
		//recursión hacia la derecha del árbol
		if(!raiz->de.EsVacio())
			raiz->de.BuscaInserta(nuevo);
		else
			raiz->de.raiz = nuevo;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rbx, %rdi
callq 0x38de
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x38de
ucomisd -0x18(%rbp), %xmm0
jbe 0x6235
movq (%r14), %rax
leaq 0x18(%rax), %r14
cmpq $0x0, 0x18(%rax)
jne 0x6209
jmp 0x6263
movq %rbx, %rdi
callq 0x38de
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x38de
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x6266
movq (%r14), %rax
leaq 0x38(%rax), %r14
cmpq $0x0, 0x38(%rax)
jne 0x6209
movq %rbx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::Reordenar()
void TAVLPoro::Reordenar() {
	if(!EsVacio())
	{
		raiz->iz.Reordenar();
		raiz->de.Reordenar();
		raiz->fe = raiz->de.Altura() - raiz->iz.Altura();
		if(raiz->fe!=-1 && raiz->fe!=0 && raiz->fe!=1)
		{
			//Rotación DD (+2, +1)
			if(raiz->fe==2 && (raiz->de.raiz->fe==1 || raiz->de.raiz->fe==0))
				RotaDD();
			else if(raiz->fe==-2 && (raiz->iz.raiz->fe==-1 || raiz->iz.raiz->fe==0))
				RotaII();
			else if(raiz->fe==-2 && raiz->iz.raiz->fe==1)
				RotaID();
			else if(raiz->fe==2 && raiz->de.raiz->fe==-1)
				RotaDI();
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x63f7
addq $0x18, %rdi
callq 0x6314
movq (%rbx), %rdi
addq $0x38, %rdi
callq 0x6314
movq (%rbx), %r13
leaq 0x38(%r13), %r14
movq %r14, %rdi
callq 0x6406
movl %eax, %r15d
leaq 0x18(%r13), %r12
movq %r12, %rdi
callq 0x6406
subl %eax, %r15d
movl %r15d, 0x58(%r13)
je 0x63f7
cmpl $-0x2, %r15d
je 0x639c
cmpl $0x2, %r15d
jne 0x63f7
movq (%r14), %rax
movl 0x58(%rax), %ecx
cmpl $0x1, %ecx
ja 0x63c1
movq 0x18(%rax), %rcx
movq %rax, (%rbx)
movq %rcx, 0x38(%r13)
movq (%rbx), %rax
movq %r13, 0x18(%rax)
jmp 0x63f7
movq (%r12), %rax
movl 0x58(%rax), %eax
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x63dc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6290
cmpl $-0x1, %ecx
jne 0x63f7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x62de
cmpl $0x1, %eax
jne 0x63f7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x62b4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::Altura() const
int TAVLPoro::Altura() const{
	int a1, a2;
	if(!EsVacio())
	{
		a1 = raiz->iz.Altura();
		a2 = raiz->de.Altura();
		return (1 + (a1<a2 ? a2:a1));
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x6438
leaq 0x18(%rbx), %rdi
callq 0x6406
movl %eax, %r14d
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x6406
cmpl %eax, %r14d
cmovgl %r14d, %eax
incl %eax
jmp 0x643a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x60
popq %rdi
callq 0x10e0
movq %rax, %r14
movq %rax, %rdi
callq 0x5cc0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3742
cmpq $0x0, (%rbx)
je 0x64a7
movq %r15, %rdi
callq 0x38de
cvttsd2si %xmm0, %eax
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x615a
testb %al, %al
je 0x64ae
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61f8
movq %rbx, %rdi
callq 0x6314
jmp 0x64aa
movq %r14, (%rbx)
movb $0x1, %al
jmp 0x64b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r14, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x3770
movl %eax, %r15d
testb %al, %al
jne 0x6541
movq %rbx, %rdi
callq 0x38de
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x38de
ucomisd -0x20(%rbp), %xmm0
jbe 0x6517
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x654f
movq %rbx, %rdi
callq 0x38de
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x38de
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x6541
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x6555
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x18, %rdi
jmp 0x6559
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x60e4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r15
testq %r15, %r15
je 0x65e1
leaq 0x18(%r15), %rbx
movq %rbx, %rdi
callq 0x65a4
movl %eax, %r14d
leaq 0x38(%r15), %rdi
callq 0x65a4
addl %r14d, %eax
cmpq $0x0, 0x38(%r15)
jne 0x65e3
cmpq $0x1, (%rbx)
adcl $0x0, %eax
jmp 0x65e3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1c(%rbp), %r15
movl $0x1, (%r15)
movq %rsi, %rdi
callq 0x6140
movq %rbx, %rdi
movl %eax, %esi
callq 0x39da
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5f14
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bb6
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x675b
movq %rax, %r14
movq 0x38(%rax), %rax
testq %rax, %rax
jne 0x6734
movq %r14, %rsi
callq 0x3742
movq (%rbx), %rdi
addq $0x18, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x6760
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %rdi
callq 0x5f70
movq (%rbx), %rax
leaq 0x18(%rax), %rsi
cmpq $0x0, 0x38(%rax)
movq 0x18(%rax), %rcx
je 0x67c0
addq $0x38, %rax
testq %rcx, %rcx
cmoveq %rax, %rsi
jmp 0x67c5
testq %rcx, %rcx
je 0x67ea
leaq -0x28(%rbp), %rdi
callq 0x5e36
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x5e36
leaq -0x28(%rbp), %rdi
callq 0x607e
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x607e
jmp 0x67da
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x607e
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, (%rdi)
je 0x6852
movq %rsi, %r14
movq %rdi, %rbx
callq 0x60e4
testb %al, %al
je 0x6852
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3770
testb %al, %al
je 0x6869
movq (%rbx), %rax
cmpq $0x0, 0x38(%rax)
je 0x6856
cmpq $0x0, 0x18(%rax)
je 0x6856
movq %rbx, %rdi
callq 0x671e
jmp 0x685e
xorl %eax, %eax
jmp 0x6860
movq %rbx, %rdi
callq 0x678c
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x38de
movsd %xmm0, -0x18(%rbp)
movq (%rbx), %rdi
callq 0x38de
ucomisd -0x18(%rbp), %xmm0
jbe 0x6895
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x6895
addq $0x18, %rdi
jmp 0x68ac
movq %r14, %rdi
callq 0x38de
movq (%rbx), %rdi
callq 0x38de
movq (%rbx), %rdi
addq $0x38, %rdi
movq %r14, %rsi
callq 0x6760
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/XmlCode.cpp
// Function: main
int main(int argc, char* argv[])
{
	OPTION_S stOpt = {0, {0}};

	//parse command
	COption COpt;
	COpt.SetLongOpt("xml", 1, NULL, 'x');
	COpt.SetLongOpt("help", 0, NULL, 'h');
	COption::RST_C CRst;
	COpt.Parse(argc, argv, CRst);

	if (!CRst.empty()) {
		for (COption::RST_ITERATOR_C iterOpt = CRst.begin(); iterOpt != CRst.end(); ++iterOpt) {
			switch (iterOpt->first) {
				case 'x':
					strcpy(stOpt.m_szXMLFile, iterOpt->second.c_str());
					break;
                case 'h':
                    stOpt.m_iHelp = 1;
				default:
					break;
			}
		}
	}

	if (stOpt.m_iHelp > 0 || STR_EMPTY(stOpt.m_szXMLFile)) {
		NUtility::PrintHelp(argv[0]);
        return 0;
	}

	//system run
	CMain CSys;
	CSys.Core(&stOpt);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x548, %rsp            # imm = 0x548
movq %rsi, %rbx
movl %edi, 0xc(%rsp)
leaq 0x34(%rsp), %rdi
movl $0x104, %edx            # imm = 0x104
xorl %esi, %esi
callq 0x41d0
leaq 0x138(%rsp), %r14
movq %r14, %rdi
callq 0x7628
leaq 0x10(%rsp), %rdx
movl $0x1, (%rdx)
movq %rsp, %r8
movl $0x78, (%r8)
leaq 0x13819(%rip), %rsi     # 0x180fa
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x765e
leaq 0x10(%rsp), %rdx
andl $0x0, (%rdx)
movq %rsp, %r8
movl $0x68, (%r8)
leaq 0x13700(%rip), %rsi     # 0x18004
leaq 0x138(%rsp), %rdi
xorl %ecx, %ecx
callq 0x765e
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
leaq 0x138(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movq %rbx, %rdx
callq 0x7694
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r12
cmpq %r12, %r15
je 0x49ad
xorl %ebp, %ebp
leaq 0x38(%rsp), %r14
pushq $0x1
popq %r13
cmpq %r12, %r15
je 0x4983
movl (%r15), %eax
cmpl $0x68, %eax
je 0x4972
cmpl $0x78, %eax
jne 0x497d
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x42d0
jmp 0x497d
movl $0x1, 0x34(%rsp)
movl %r13d, %ebp
addq $0x28, %r15
jmp 0x4952
testl %ebp, %ebp
jg 0x49ad
cmpb $0x0, 0x38(%rsp)
je 0x49ad
movq %rsp, %rdi
callq 0x7a34
movq %rsp, %rdi
leaq 0x34(%rsp), %rsi
callq 0x7a4a
movq %rsp, %rdi
callq 0x7a40
jmp 0x49b5
movq (%rbx), %rdi
callq 0x7544
leaq 0x10(%rsp), %rdi
callq 0x4a18
leaq 0x138(%rsp), %rdi
callq 0x7642
xorl %eax, %eax
addq $0x548, %rsp            # imm = 0x548
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7a40
jmp 0x49f9
jmp 0x49f6
jmp 0x49f1
movq %rax, %rbx
jmp 0x4a03
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4a18
leaq 0x138(%rsp), %rdi
callq 0x7642
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movl %r13d, %r13d
movq 0x78(%r15), %rax
movq 0x80(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x4c81
movq (%rax,%r13,8), %rsi
addq $0x8, %rsi
movq %r12, %rdi
callq 0x4410
movq %r14, %rdi
movq %r12, %rsi
callq 0x5457
movl %eax, %ebp
movq %r12, %rdi
callq 0x4160
testb %bpl, %bpl
je 0x4c7c
leaq (,%r13,8), %rsi
addq 0x78(%r15), %rsi
movq %rbx, %rdi
callq 0x543a
incl %r13d
jmp 0x4c24
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c95
movq %rax, %r14
movq %rbx, %rdi
callq 0x5584
movq %r14, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x2d
popq %rbp
movl (%rbx), %eax
addl %eax, %eax
cmpl %eax, %r12d
jae 0x4cf0
movl %ebp, %edi
callq 0x4420
incl %r12d
jmp 0x4cdb
leaq 0x8(%r15), %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x4410
movq (%r12), %rsi
leaq 0x132fd(%rip), %rdi     # 0x18009
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x4040
movq %r12, %rdi
callq 0x4160
leaq 0x78(%r15), %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x5536
movq (%r12), %rax
cmpq 0x8(%r12), %rax
je 0x4d79
pushq $0xa
popq %rdi
callq 0x4420
leaq 0x18(%rsp), %r15
movl %r13d, %r13d
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x4da8
movq (%rax,%r13,8), %rsi
movl (%rbx), %eax
incl %eax
movl %eax, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0x4cbe
incl %r13d
jmp 0x4d45
addq $0x28, %r15
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x4410
leaq 0x18(%rsp), %rbx
movq (%rbx), %rsi
leaq 0x13273(%rip), %rdi     # 0x1800c
xorl %eax, %eax
callq 0x4040
movq %rbx, %rdi
callq 0x4160
movq %rsp, %rdi
callq 0x5584
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4dc1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5584
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rsi, %rdi
callq 0x45a0
movq %rax, %rbx
testq %rax, %rax
je 0x4e96
movq %rbx, %rdi
callq 0x44b0
testq %rax, %rax
je 0x4e8e
movq %rax, %r15
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x5480
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x4ebe
leaq 0x8(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4610
testq %rbx, %rbx
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLTree::GetNode(CXMLNode*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<CXMLNode*, std::allocator<CXMLNode*>>&)
void CXMLTree::GetNode(CXMLNode* pCNode, const std::string& strPath, std::vector<CXMLNode *>& vecNode)
{
	std::string strName = GetNodeName(strPath);
	if (pCNode != NULL && !strName.empty()) {
		std::vector<CXMLNode *> vecChild =  pCNode->GetChildren(strName);
		if (IsLastName(strName, strPath)) {
			for (unsigned int uiCount = 0; uiCount < vecChild.size(); ++uiCount) {
				vecNode.push_back(vecChild[uiCount]);
			}
		} else {
			for (unsigned int uiCount = 0; uiCount < vecChild.size(); ++uiCount) {
				GetNode(vecChild[uiCount], strPath.c_str() + strName.length(), vecNode);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x28(%rsp), %rdi
callq 0x529a
testq %r12, %r12
je 0x51e7
cmpq $0x0, 0x30(%rsp)
je 0x51e7
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r12, %rsi
callq 0x4bfa
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x5302
testb %al, %al
je 0x5185
xorl %r14d, %r14d
movl %r14d, %r14d
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x51dd
leaq (%rax,%r14,8), %rsi
movq %rbx, %rdi
callq 0x543a
incl %r14d
jmp 0x515b
xorl %r13d, %r13d
leaq 0x48(%rsp), %r12
movl %r13d, %r13d
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x51dd
movq (%rax,%r13,8), %rbp
movq (%r14), %rsi
addq 0x30(%rsp), %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0x5480
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x50fc
movq %r12, %rdi
callq 0x4160
incl %r13d
jmp 0x518d
leaq 0x10(%rsp), %rdi
callq 0x5584
leaq 0x28(%rsp), %rdi
callq 0x4160
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5223
jmp 0x5216
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4160
jmp 0x5219
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5584
leaq 0x28(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
pushq $0x2f
popq %rsi
movq %rdx, %rdi
xorl %edx, %edx
callq 0x4280
cmpq $-0x1, %rax
je 0x52e9
movq %rax, %r15
pushq $0x2f
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x43f0
cmpq $-0x1, %rax
jne 0x52d3
movq 0x8(%r14), %rax
subq %r15, %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x4320
jmp 0x52f9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
xorl %r14d, %r14d
movq %rdx, %rdi
xorl %edx, %edx
callq 0x4680
cmpq $-0x1, %rax
je 0x534f
addq 0x8(%r15), %rax
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
movq %rax, %rdx
cmovaq %rcx, %rdx
cmpq %rcx, %rax
jae 0x5348
cmpb $0x2f, (%rsi,%rax)
jne 0x5345
incq %rax
jmp 0x5335
movq %rax, %rdx
cmpq %rcx, %rdx
sete %r14b
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x78, %rsi
leaq 0x8(%rsp), %rdi
callq 0x5536
xorl %r15d, %r15d
movl %r15d, %r15d
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x53a2
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x5358
incl %r15d
jmp 0x5378
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x5584
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5584
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r14
addq $0x48, %rsi
leaq 0x28(%rsp), %rdi
callq 0x682c
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4b8a
leaq 0x30(%rsp), %r12
movq 0x10(%r12), %r13
leaq 0x58(%rsp), %r14
leaq 0x78(%rsp), %r15
cmpq %r12, %r13
je 0x646f
leaq 0x20(%r13), %rbp
movq %r14, %rdi
movq %rbp, %rsi
callq 0x7602
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x673d
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0xac4e
movq %r15, %rdi
callq 0x4160
movq %r14, %rdi
callq 0x4160
movq %r13, %rdi
callq 0x41f0
movq %rax, %r13
jmp 0x6420
leaq 0x8(%rsp), %rdi
callq 0x4160
leaq 0x28(%rsp), %rdi
callq 0x54bc
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x64c5
movq %rax, %rbx
jmp 0x64bb
movq %rax, %rbx
jmp 0x64b1
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x4160
leaq 0x58(%rsp), %rdi
callq 0x4160
leaq 0x8(%rsp), %rdi
callq 0x4160
leaq 0x28(%rsp), %rdi
callq 0x54bc
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
callq 0x40d0
testl %eax, %eax
jne 0x75c4
callq 0x4350
leaq 0x10b66(%rip), %rdi     # 0x180eb
pushq $0x2
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4220
cmpl $-0x1, %eax
je 0x75c2
movl %eax, %ebx
movl %eax, %edi
xorl %esi, %esi
callq 0x42c0
pushq $0x1
popq %rsi
movl %ebx, %edi
callq 0x42c0
pushq $0x2
popq %rsi
movl %ebx, %edi
callq 0x42c0
cmpl $0x3, %ebx
jl 0x75c2
movl %ebx, %edi
popq %rbx
jmp 0x4660
popq %rbx
retq
xorl %edi, %edi
callq 0x4390
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
pushq $0x4
popq %rdi
callq 0x4440
testl %eax, %eax
jne 0x75f3
movq %rsp, %rsi
orq $-0x1, (%rsi)
pushq $0x4
popq %rdi
callq 0x42a0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x408(%rdi), %eax
cmpq $0x1f, %rax
ja 0x7692
movq %rax, %r9
shlq $0x5, %r9
movq %rsi, 0x8(%rdi,%r9)
movl (%rdx), %edx
movl %edx, 0x10(%rdi,%r9)
movq %rcx, 0x18(%rdi,%r9)
movl (%r8), %ecx
movl %ecx, 0x20(%rdi,%r9)
incl %eax
movl %eax, 0x408(%rdi)
retq
nop