LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x18(%rdi)
je 0x6517
leaq 0x18(%rdi), %rax
movq (%rax), %r14
leaq 0x38(%r14), %rax
cmpq $0x0, 0x38(%r14)
jne 0x64ee
movq %r14, %rsi
callq 0x43e4
movq (%rbx), %rdi
addq $0x18, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x636c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x442a
movl %eax, %r15d
testb %al, %al
jne 0x658b
movq %rbx, %rdi
callq 0x4614
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x4614
ucomisd -0x20(%rbp), %xmm0
jbe 0x6561
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x6599
movq %rbx, %rdi
callq 0x4614
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x4614
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x658b
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x659f
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x18, %rdi
jmp 0x65a3
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x613a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x434e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6604
leaq 0x18(%rbx), %rdi
callq 0x65d2
movl %eax, %r14d
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x65d2
cmpl %eax, %r14d
cmovgl %r14d, %eax
incl %eax
jmp 0x6606
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6691
leaq 0x18(%r15), %rbx
movq %rbx, %rdi
callq 0x664e
movl %eax, %r14d
leaq 0x38(%r15), %rdi
callq 0x664e
addl %r14d, %eax
xorl %ecx, %ecx
cmpq $0x0, 0x38(%r15)
jne 0x668d
xorl %ecx, %ecx
cmpq $0x0, (%rbx)
sete %cl
addl %ecx, %eax
jmp 0x6693
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %esi, %esi
callq 0x660c
movq %rbx, %rdi
movl %eax, %esi
callq 0x476c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5d52
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4966
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4744
cmpq $0x0, (%r14)
je 0x67fd
movq %r14, %rdi
xorl %esi, %esi
callq 0x660c
movq %rbx, %rdi
movl %eax, %esi
callq 0x4c34
leaq -0x14(%rbp), %rdx
movl $0x1, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e5e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x680b
movq %rax, %r14
movq %rbx, %rdi
callq 0x4966
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6004
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x669e
movl $0x1, %r14d
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x4bdc
cmpl %eax, %r14d
jg 0x6874
movq %r15, %rdi
movl %r14d, %esi
callq 0x4b56
movq %rbx, %rdi
movq %rax, %rsi
callq 0x62de
incl %r14d
jmp 0x684c
leaq -0x40(%rbp), %rdi
callq 0x4966
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x689c
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x4966
cmpq $0x0, (%rbx)
je 0x68a9
movq $0x0, (%rbx)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x43b2
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq -0x50(%rbp), %rdi
callq 0x669e
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x4210
movq $0x0, (%rbx)
movl $0x1, %r12d
leaq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0x4bdc
cmpl %eax, %r12d
jg 0x6943
movq %r13, %rdi
movl %r12d, %esi
callq 0x4b56
cmpq $0x0, (%r15)
je 0x6928
movq %r15, %rdi
movq %rax, %rsi
callq 0x651c
testb %al, %al
jne 0x693e
movq %r13, %rdi
movl %r12d, %esi
callq 0x4b56
movq %rbx, %rdi
movq %rax, %rsi
callq 0x62de
incl %r12d
jmp 0x68fb
leaq -0x50(%rbp), %rdi
callq 0x4966
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x697b
movq %rax, %r15
cmpq $0x0, (%rbx)
je 0x6973
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x43b2
leaq -0x50(%rbp), %rdi
callq 0x4966
movq %r15, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43e4
cmpq $0x0, 0x38(%r14)
je 0x6f04
leaq 0x38(%r14), %rsi
leaq 0x38(%rbx), %rdi
callq 0x6f9a
cmpq $0x0, 0x18(%r14)
je 0x6f18
leaq 0x18(%r14), %rsi
leaq 0x18(%rbx), %rdi
callq 0x6f9a
movl 0x58(%r14), %eax
movl %eax, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6f83
movq %rsi, %r14
movq %rbx, %rdi
callq 0x6f24
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6ede
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6fc7
movq %rsi, %r14
movq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
callq 0x43b2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x70fc
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x701e
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6fd0
movq (%r15), %r12
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4b56
movq %rax, %rdi
movq %r12, %rsi
callq 0x43e4
incl (%rbx)
movq (%r15), %r15
addq $0x38, %r15
jmp 0x6fe4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7076
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4b56
movq %rax, %rdi
movq %r12, %rsi
callq 0x43e4
incl (%rbx)
movq (%r15), %rdi
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7028
movq (%r15), %r15
addq $0x38, %r15
jmp 0x703c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x70d0
movq %rdx, %rbx
movq %rsi, %r14
addq $0x18, %rdi
callq 0x7080
movq (%r15), %rdi
addq $0x38, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7080
movq (%r15), %r15
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4b56
movq %rax, %rdi
movq %r15, %rsi
callq 0x43e4
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7182
movq %rsi, %rbx
movl $0x60, %edi
callq 0x10f0
movq %rax, %r15
movq %rax, %rdi
callq 0x6ddc
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x43e4
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 0x70fc
movq (%r14), %rdi
addq $0x38, %rdi
movq (%rbx), %rsi
addq $0x38, %rsi
callq 0x70fc
addq $0x8, %rbx
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x43e4
movq $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x60, %esi
movq %r15, %rdi
callq 0x1100
movq %rbx, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rsi
testq %rsi, %rsi
je 0x724f
cmpq $0x0, (%rbx)
je 0x724b
movq %rbx, %rdi
callq 0x7696
testb %al, %al
je 0x724b
movq (%r14), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
callq 0x7208
testb %al, %al
je 0x724b
movq (%r14), %r14
addq $0x38, %r14
jmp 0x7215
xorl %eax, %eax
jmp 0x7251
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7266
popq %rbp
jmp 0x7696
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::operator==(TAVLPoro const&) const
bool TAVLPoro::operator ==(const TAVLPoro &otroArbol) const {
	if(Nodos() == otroArbol.Nodos())
		return CompruebaNodos(otroArbol);
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x7726
movl %eax, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7726
cmpl %eax, %r15d
jne 0x72a8
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7208
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4614
cvtsi2sdl (%rbx), %xmm1
ucomisd %xmm1, %xmm0
jne 0x72f5
jnp 0x734b
movsd %xmm0, -0x28(%rbp)
movq (%r14), %rdi
movsd %xmm1, -0x18(%rbp)
callq 0x4614
ucomisd -0x18(%rbp), %xmm0
jbe 0x7318
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x7361
xorps %xmm0, %xmm0
cvtsi2sdl (%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x4614
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
jbe 0x734b
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x7367
cmpneqsd %xmm1, %xmm0
movq %xmm0, %rax
andl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x18, %rdi
jmp 0x736b
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x72d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4614
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x4614
ucomisd -0x18(%rbp), %xmm0
jbe 0x73b1
movq (%r14), %rax
leaq 0x18(%rax), %r14
cmpq $0x0, 0x18(%rax)
jne 0x7385
jmp 0x73df
movq %rbx, %rdi
callq 0x4614
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x4614
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x73e2
movq (%r14), %rax
leaq 0x38(%rax), %r14
cmpq $0x0, 0x38(%rax)
jne 0x7385
movq %rbx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::RotaDD()
void TAVLPoro::RotaDD()
{
	TNodoAVL *b = raiz;
	TNodoAVL *d = raiz->de.raiz;
	TNodoAVL *c = raiz->de.raiz->iz.raiz;
	raiz = d;
	b->de.raiz = c;
	raiz->iz.raiz = b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x38(%rax), %rcx
movq 0x18(%rcx), %rdx
movq %rcx, (%rdi)
movq %rdx, 0x38(%rax)
movq (%rdi), %rcx
movq %rax, 0x18(%rcx)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::RotaII()
void TAVLPoro::RotaII() {
	TNodoAVL *d = raiz;
	TNodoAVL *b = raiz->iz.raiz;
	TNodoAVL *c = b->de.raiz;
	raiz = raiz->iz.raiz;
	raiz->de.raiz = d;
	raiz->de.raiz->iz.raiz = c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x18(%rax), %rcx
movq 0x38(%rcx), %rdx
movq %rcx, (%rdi)
movq %rax, 0x38(%rcx)
movq (%rdi), %rax
movq 0x38(%rax), %rax
movq %rdx, 0x18(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7509
addq $0x18, %rdi
callq 0x74b4
movq (%rbx), %rdi
addq $0x38, %rdi
callq 0x74b4
movq (%rbx), %r13
leaq 0x38(%r13), %r14
movq %r14, %rdi
callq 0x75c6
movl %eax, %r15d
leaq 0x18(%r13), %r12
movq %r12, %rdi
callq 0x75c6
subl %eax, %r15d
movl %r15d, 0x58(%r13)
jne 0x7518
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x1, %r15d
je 0x7509
cmpl $0x1, %r15d
je 0x7509
cmpl $0x2, %r15d
jne 0x7547
movq (%r14), %rax
cmpl $0x1, 0x58(%rax)
ja 0x7547
movq 0x18(%rax), %rcx
movq %rax, (%rbx)
movq %rcx, 0x38(%r13)
movq (%rbx), %rax
movq %r13, 0x18(%rax)
jmp 0x7509
cmpl $-0x2, %r15d
jne 0x7599
movq (%r12), %rax
movl 0x58(%rax), %ecx
incl %ecx
cmpl $0x1, %ecx
ja 0x7573
movq 0x38(%rax), %rcx
movq %rax, (%rbx)
movq %r13, 0x38(%rax)
movq (%rbx), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x7509
cmpl $-0x2, %r15d
jne 0x7599
movq (%r12), %rax
cmpl $0x1, 0x58(%rax)
jne 0x7599
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7430
cmpl $0x2, %r15d
jne 0x7509
movq (%r14), %rax
cmpl $-0x1, 0x58(%rax)
jne 0x7509
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7472
// File: /workspace/github_cpp_makefile_star2_O1/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 0x75f8
leaq 0x18(%rbx), %rdi
callq 0x75c6
movl %eax, %r14d
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x75c6
cmpl %eax, %r14d
cmovgl %r14d, %eax
incl %eax
jmp 0x75fa
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x60, %edi
callq 0x10f0
movq %rax, %r14
movq %rax, %rdi
callq 0x6ddc
movq %r14, %rdi
movq %r15, %rsi
callq 0x43e4
cmpq $0x0, (%rbx)
je 0x7669
movq %r15, %rdi
callq 0x4614
cvttsd2si %xmm0, %eax
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x72d0
testb %al, %al
je 0x7670
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7374
movq %rbx, %rdi
callq 0x74b4
jmp 0x766c
movq %r14, (%rbx)
movb $0x1, %al
jmp 0x7672
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x60, %esi
movq %r14, %rdi
callq 0x1100
movq %rbx, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x442a
movl %eax, %r15d
testb %al, %al
jne 0x7705
movq %rbx, %rdi
callq 0x4614
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x4614
ucomisd -0x20(%rbp), %xmm0
jbe 0x76db
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x7713
movq %rbx, %rdi
callq 0x4614
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x4614
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7705
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x7719
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x18, %rdi
jmp 0x771d
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x7256
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x77ab
leaq 0x18(%r15), %rbx
movq %rbx, %rdi
callq 0x7768
movl %eax, %r14d
leaq 0x38(%r15), %rdi
callq 0x7768
addl %r14d, %eax
xorl %ecx, %ecx
cmpq $0x0, 0x38(%r15)
jne 0x77a7
xorl %ecx, %ecx
cmpq $0x0, (%rbx)
sete %cl
addl %ecx, %eax
jmp 0x77ad
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %esi, %esi
callq 0x7726
movq %rbx, %rdi
movl %eax, %esi
callq 0x476c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x7080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4966
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x18(%rdi)
je 0x792f
leaq 0x18(%rdi), %rax
movq (%rax), %r14
leaq 0x38(%r14), %rax
cmpq $0x0, 0x38(%r14)
jne 0x7906
movq %r14, %rsi
callq 0x43e4
movq (%rbx), %rdi
addq $0x18, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7934
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x4210
movq $0x0, -0x8(%rbx)
movq (%r14), %rsi
movq 0x38(%rsi), %rax
testq %rax, %rax
jne 0x7995
cmpq $0x0, 0x18(%rsi)
je 0x79c4
movq 0x18(%rsi), %rcx
orq %rcx, %rax
je 0x79d7
leaq 0x38(%rsi), %rax
addq $0x18, %rsi
testq %rcx, %rcx
cmoveq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x6f9a
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x6f9a
jmp 0x79d7
movq $0x0, (%r14)
addq $0x8, %r14
movq %r14, %rdi
callq 0x43b2
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x43b2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x43b2
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7a64
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7696
testb %al, %al
je 0x7a64
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x442a
testb %al, %al
je 0x7a7b
movq (%rbx), %rax
movq 0x38(%rax), %rcx
testq %rcx, %rcx
jne 0x7a4e
cmpq $0x0, 0x18(%rax)
je 0x7a68
testq %rcx, %rcx
je 0x7a68
cmpq $0x0, 0x18(%rax)
je 0x7a68
movq %rbx, %rdi
callq 0x78ee
jmp 0x7a70
xorl %eax, %eax
jmp 0x7a72
movq %rbx, %rdi
callq 0x7960
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x4614
movsd %xmm0, -0x18(%rbp)
movq (%rbx), %rdi
callq 0x4614
ucomisd -0x18(%rbp), %xmm0
jbe 0x7aa1
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x7aac
movq %r14, %rdi
movq %rbx, %rsi
callq 0x121d
addq $0x18, %rdi
movq %r14, %rsi
callq 0x7934
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
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 0x41b0
leaq 0x138(%rsp), %r14
movq %r14, %rdi
callq 0x7f08
leaq 0x10(%rsp), %rdx
movl $0x1, (%rdx)
movq %rsp, %r8
movl $0x78, (%r8)
leaq 0x22572(%rip), %rsi     # 0x27110
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x7f56
leaq 0x10(%rsp), %rdx
movl $0x0, (%rdx)
movq %rsp, %r8
movl $0x68, (%r8)
leaq 0x22440(%rip), %rsi     # 0x27004
leaq 0x138(%rsp), %rdi
xorl %ecx, %ecx
callq 0x7f56
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x138(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movq %rbx, %rdx
callq 0x7f8c
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r12
cmpq %r12, %r15
je 0x4c3b
leaq 0x38(%rsp), %r14
movl (%r15), %eax
cmpl $0x68, %eax
je 0x4c2a
cmpl $0x78, %eax
jne 0x4c32
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x42c0
jmp 0x4c32
movl $0x1, 0x34(%rsp)
addq $0x28, %r15
cmpq %r12, %r15
jne 0x4c0f
cmpl $0x0, 0x34(%rsp)
jg 0x4c68
cmpb $0x0, 0x38(%rsp)
je 0x4c68
movq %rsp, %rdi
callq 0x843c
movq %rsp, %rdi
leaq 0x34(%rsp), %rsi
callq 0x8454
movq %rsp, %rdi
callq 0x8448
jmp 0x4c70
movq (%rbx), %rdi
callq 0x7e00
leaq 0x10(%rsp), %rdi
callq 0x4cd0
leaq 0x138(%rsp), %rdi
callq 0x7f22
xorl %eax, %eax
addq $0x548, %rsp            # imm = 0x548
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8448
jmp 0x4cb1
jmp 0x4cae
jmp 0x4ca9
movq %rax, %rbx
jmp 0x4cbb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4cd0
leaq 0x138(%rsp), %rdi
callq 0x7f22
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x78(%rsi), %rax
cmpq %rax, 0x80(%rsi)
je 0x4ff4
movq %rdx, %r14
movq %rsi, %r15
movl $0x1, %ebp
xorl %r13d, %r13d
movq (%rax,%r13,8), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x5c16
movq 0x8(%r14), %rdx
cmpq 0x10(%rsp), %rdx
jne 0x4f80
testq %rdx, %rdx
je 0x4f85
movq 0x8(%rsp), %rsi
movq (%r14), %rdi
callq 0x4300
testl %eax, %eax
sete %r12b
jmp 0x4f88
xorl %r12d, %r12d
jmp 0x4f88
movb $0x1, %r12b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4fa4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
testb %r12b, %r12b
je 0x4fd4
shlq $0x3, %r13
addq 0x78(%r15), %r13
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4fc9
movq (%r13), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4fd4
movq %rbx, %rdi
movq %r13, %rdx
callq 0x6024
movl %ebp, %r13d
movq 0x78(%r15), %rax
movq 0x80(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %r13, %rcx
ja 0x4f38
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5008
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x501f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x42f0
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
testl $0x7fffffff, (%rdx)     # imm = 0x7FFFFFFF
je 0x5073
xorl %ebp, %ebp
movl $0x2d, %edi
callq 0x4400
incl %ebp
movl (%rbx), %eax
addl %eax, %eax
cmpl %eax, %ebp
jb 0x505f
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x5c16
movq (%r12), %rsi
leaq 0x21f6a(%rip), %rdi     # 0x27009
xorl %eax, %eax
callq 0x4050
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x50bc
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42f0
leaq 0x78(%r15), %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x5b7a
movq (%r12), %rax
cmpq 0x8(%r12), %rax
je 0x512d
movl $0xa, %edi
callq 0x4400
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x516f
movl $0x1, %ebp
xorl %ecx, %ecx
leaq 0x18(%rsp), %r15
movq (%rax,%rcx,8), %rsi
movl (%rbx), %eax
incl %eax
movl %eax, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0x503e
movl %ebp, %ecx
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x50fb
jmp 0x516f
leaq 0x18(%rsp), %rdi
movq %r13, (%rdi)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
callq 0x5c16
movq 0x18(%rsp), %rsi
leaq 0x21ebb(%rip), %rdi     # 0x2700c
xorl %eax, %eax
callq 0x4050
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x516f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42f0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5185
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5196
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x51af
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4570
movq %rax, %rbx
testq %rax, %rax
je 0x52ad
movq %rbx, %rdi
callq 0x4490
testq %rax, %rax
je 0x52a5
movq %rax, %r15
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x5aaa
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x52e6
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45f0
testq %rbx, %rbx
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52dd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x58bc
testq %r12, %r12
je 0x57c0
cmpq $0x0, 0x30(%rsp)
je 0x57c0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r12, %rsi
callq 0x4efa
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x592c
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
testb %al, %al
je 0x5735
cmpq %rcx, %rdx
je 0x57a9
movl $0x1, %ebp
xorl %eax, %eax
leaq (%rcx,%rax,8), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5711
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x5719
movq %rbx, %rdi
callq 0x6024
movl %ebp, %eax
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rax, %rdx
ja 0x56f6
jmp 0x57a9
cmpq %rcx, %rdx
je 0x57a9
movl $0x1, %r13d
xorl %eax, %eax
leaq 0x48(%rsp), %r12
movq (%rcx,%rax,8), %rbp
movq (%r14), %rsi
addq 0x30(%rsp), %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0x5aaa
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x5680
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x578d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42f0
movl %r13d, %eax
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
incl %r13d
cmpq %rax, %rdx
ja 0x5747
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x57c0
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57db
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x582c
jmp 0x57f1
movq %rax, %rbx
jmp 0x5815
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x5815
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42f0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x582c
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5847
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdx, %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x4270
cmpq $-0x1, %rax
je 0x590f
movq %rax, %r15
movq %r14, %rdi
movl $0x2f, %esi
movq %rax, %rdx
callq 0x43e0
cmpq $-0x1, %rax
jne 0x58f9
movq 0x8(%r14), %rax
subq %r15, %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x4310
jmp 0x5922
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq (%rsi), %rsi
movq 0x8(%r15), %rcx
xorl %r14d, %r14d
movq %rdx, %rdi
xorl %edx, %edx
callq 0x4590
cmpq $-0x1, %rax
je 0x5979
addq 0x8(%r15), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jae 0x5972
movq (%rbx), %rdx
cmpb $0x2f, (%rdx,%rax)
jne 0x5972
incq %rax
cmpq %rcx, %rax
jb 0x5961
movq %rcx, %rax
cmpq %rcx, %rax
sete %r14b
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x78, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x5b7a
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x59d6
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rsi
movq %r14, %rdi
callq 0x5982
movl %ebp, %ecx
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x59b1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x59f5
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5a19
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68(%rsp), %rdi
callq 0x718c
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4e58
leaq 0x70(%rsp), %rbp
movq 0x10(%rbp), %r14
cmpq %rbp, %r14
je 0x6c8d
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r15
leaq 0x20(%r14), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x7ecd
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4360
movq %r12, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6c16
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x6c1e
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0xca1e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6c5d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x6c79
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %r14, %rdi
callq 0x41e0
movq %rax, %r14
cmpq %rbp, %rax
jne 0x6bce
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ca8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42f0
leaq 0x68(%rsp), %rdi
callq 0x5ae8
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6d24
movq %rax, %rbx
jmp 0x6d09
movq %rax, %rbx
jmp 0x6ced
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6ced
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x6d09
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42f0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d24
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42f0
leaq 0x68(%rsp), %rdi
callq 0x5ae8
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40b0
testl %eax, %eax
jne 0x7e86
callq 0x4340
leaq 0x1f2c0(%rip), %rdi     # 0x27101
movl $0x2, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4210
cmpl $-0x1, %eax
je 0x7e84
movl %eax, %ebx
movl %eax, %edi
xorl %esi, %esi
callq 0x42b0
movl %ebx, %edi
movl $0x1, %esi
callq 0x42b0
movl %ebx, %edi
movl $0x2, %esi
callq 0x42b0
cmpl $0x3, %ebx
jl 0x7e84
movl %ebx, %edi
popq %rbx
jmp 0x4620
popq %rbx
retq
xorl %edi, %edi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl $0x4, %edi
callq 0x4420
testl %eax, %eax
jne 0x7ebc
movq %rsp, %rsi
movq $-0x1, (%rsi)
movl $0x4, %edi
callq 0x4290
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7f8a
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