LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::PreordenAux(TVectorPoro&, int&) const
void TABBPoro::PreordenAux(TVectorPoro &vector, int &posicion) const {
	if(!EsVacio())
	{
		vector[posicion] = nodo->item;
		posicion++;
		nodo->iz.PreordenAux(vector, posicion);
		nodo->de.PreordenAux(vector, posicion);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x5ce9
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4af8
movq %rax, %rdi
movq %r12, %rsi
callq 0x43e4
incl (%rbx)
movq (%r15), %rdi
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5c94
movq (%r15), %r15
movq 0x38(%r15), %r12
addq $0x38, %r15
testq %r12, %r12
jne 0x5cb0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::PostordenAux(TVectorPoro&, int&) const
void TABBPoro::PostordenAux(TVectorPoro &vector, int &posicion) const {
	if(!EsVacio())
	{
		nodo->iz.PostordenAux(vector, posicion);
		nodo->de.PostordenAux(vector, posicion);
		vector[posicion] = nodo->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 0x5d42
movq %rdx, %rbx
movq %rsi, %r14
addq $0x18, %rdi
callq 0x5cf2
movq (%r15), %rdi
addq $0x38, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5cf2
movq (%r15), %r15
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4af8
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_O3/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::NivelesAux(TVectorPoro&, int&) const
void TABBPoro::NivelesAux(TVectorPoro &vector, int &posicion) const {
	TNodoABB *aux;
	queue<TNodoABB *> cola;
	cola.push((*this).nodo);
	while(!cola.empty())
	{
		aux = cola.front();
		vector[posicion] = cola.front()->item;
		posicion++;
		cola.pop();
		if(!aux->iz.EsVacio())
			cola.push(aux->iz.nodo);
		if(!aux->de.EsVacio())
			cola.push(aux->de.nodo);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %r12
movaps %xmm0, 0x40(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %r12, %rdi
xorl %esi, %esi
callq 0x6948
movq 0x30(%r12), %rax
movq 0x40(%r12), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5dbb
movq (%r15), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x5dcb
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0x6ad0
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
cmpq %rcx, %rax
je 0x5ec3
leaq -0x70(%rbp), %r15
movq (%rcx), %r12
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4af8
movq %rax, %rdi
movq %r12, %rsi
callq 0x43e4
incl (%rbx)
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5e0d
addq $0x8, %rax
jmp 0x5e3a
movq -0x58(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x1100
movq -0x48(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
leaq 0x200(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x60(%rbp)
movq 0x18(%r12), %rcx
movq -0x40(%rbp), %rax
testq %rcx, %rcx
je 0x5e7b
movq -0x30(%rbp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rax
je 0x5e6a
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x5e7b
leaq 0x18(%r12), %rsi
movq %r15, %rdi
callq 0x6ad0
movq -0x40(%rbp), %rax
movq 0x38(%r12), %rcx
testq %rcx, %rcx
je 0x5eb6
movq -0x30(%rbp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rax
je 0x5ea3
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x5eb6
addq $0x38, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6ad0
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5ddc
leaq -0x70(%rbp), %rdi
callq 0x68e2
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5edb
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x68e2
movq %rbx, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Copiar(TABBPoro const&)
void TABBPoro::Copiar(const TABBPoro &origen){
	if(origen.nodo != NULL)
	{
		TNodoABB *aux = new TNodoABB();
		aux->item = origen.nodo->item;
		nodo = aux;
		nodo->iz.Copiar(origen.nodo->iz);
		nodo->de.Copiar(origen.nodo->de);
	}
	else
		nodo = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rsi)
je 0x5fb7
movq %rsi, %r14
movl $0x58, %edi
callq 0x10f0
movq %rax, %r15
movq %rax, %rdi
callq 0x5a1c
movq (%r14), %rsi
movq %r15, %rdi
callq 0x43e4
movq %r15, (%rbx)
addq $0x18, %r15
movq (%r14), %rsi
addq $0x18, %rsi
movq %r15, %rdi
callq 0x5f56
movq (%rbx), %rbx
addq $0x38, %rbx
movq (%r14), %rax
leaq 0x38(%rax), %r14
cmpq $0x0, 0x38(%rax)
jne 0x5f6c
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r15, %rdi
callq 0x1100
movq %rbx, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::CompruebaNodos(TABBPoro const&) const
bool TABBPoro::CompruebaNodos(const TABBPoro &otroArbol) const {
	if(EsVacio())
		return true;
	else
	{
		return (otroArbol.Buscar(nodo->item) && nodo->iz.CompruebaNodos(otroArbol) && nodo->de.CompruebaNodos(otroArbol));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rsi
movb $0x1, %bl
testq %rsi, %rsi
je 0x6051
movq %rdi, %r15
cmpq $0x0, (%r14)
je 0x604f
movq %r14, %rdi
callq 0x641e
testb %al, %al
je 0x604f
movq (%r15), %rdi
addq $0x18, %rdi
movq %r14, %rsi
callq 0x5ffe
testb %al, %al
je 0x604f
movq (%r15), %r15
movq 0x38(%r15), %rsi
addq $0x38, %r15
testq %rsi, %rsi
jne 0x6018
jmp 0x6051
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Buscar(TPoro const&) const
bool TABBPoro::Buscar(const TPoro &poro) const {
	if(EsVacio())
		return false;
	else
		return BuscarAux(poro);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, (%rdi)
je 0x606e
popq %rbp
jmp 0x641e
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::operator==(TABBPoro const&) const
bool TABBPoro::operator ==(const TABBPoro &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 0x650e
movl %eax, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x650e
cmpl %eax, %r15d
jne 0x60b0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5ffe
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::FiltraVolumen(int const&)
bool TABBPoro::FiltraVolumen(const int &volumen) {
	if(nodo->item.Volumen() == volumen)
		return false;
	else if(volumen < nodo->item.Volumen() && !nodo->iz.EsVacio())
		nodo->iz.FiltraVolumen(volumen);
	else if(volumen > nodo->item.Volumen() && !nodo->de.EsVacio())
		nodo->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 0x45c0
cvtsi2sdl (%rbx), %xmm1
ucomisd %xmm1, %xmm0
jne 0x610b
jnp 0x615e
movsd %xmm0, -0x28(%rbp)
movq (%r14), %rdi
movsd %xmm1, -0x18(%rbp)
callq 0x45c0
ucomisd -0x18(%rbp), %xmm0
movq (%r14), %rdi
jbe 0x612e
cmpq $0x0, 0x18(%rdi)
jne 0x6174
xorps %xmm0, %xmm0
cvtsi2sdl (%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x45c0
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
jbe 0x615e
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x617a
cmpneqsd %xmm1, %xmm0
movq %xmm0, %rax
andl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x18, %rdi
jmp 0x617e
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x60e6
// File: /workspace/github_cpp_makefile_star2_O3/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::BuscaInserta(TNodoABB*)
void TABBPoro::BuscaInserta(TNodoABB *nuevo){
	//Comprobar recursivamente que sea menor o mayor que el elemento nodo de la raiz e introducir donde quepa
	if(nuevo->item.Volumen() < nodo->item.Volumen())
	{
		//recursión hacia la izquierda del árbol
		if(!nodo->iz.EsVacio())
			nodo->iz.BuscaInserta(nuevo);
		else
			nodo->iz.nodo = nuevo;
	}
	else if(nuevo->item.Volumen() > nodo->item.Volumen())
	{
		//recursión hacia la derecha del árbol
		if(!nodo->de.EsVacio())
			nodo->de.BuscaInserta(nuevo);
		else
			nodo->de.nodo = nuevo;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rbx, %rdi
callq 0x45c0
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x45c0
ucomisd -0x18(%rbp), %xmm0
jbe 0x61c3
movq (%r14), %rax
leaq 0x18(%rax), %r14
cmpq $0x0, 0x18(%rax)
jne 0x6197
jmp 0x61f1
movq %rbx, %rdi
callq 0x45c0
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x45c0
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x61f4
movq (%r14), %rax
leaq 0x38(%rax), %r14
cmpq $0x0, 0x38(%rax)
jne 0x6197
movq %rbx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x58, %edi
callq 0x10f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x5a1c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43e4
cmpq $0x0, (%r14)
je 0x625f
movq %r15, %rdi
callq 0x45c0
cvttsd2si %xmm0, %eax
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x60e6
testb %al, %al
je 0x6266
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6186
jmp 0x6262
movq %rbx, (%r14)
movb $0x1, %al
jmp 0x6268
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x1100
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x62d6
movq %rsi, %r14
movq %rdi, %rbx
callq 0x641e
testb %al, %al
je 0x62d6
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x442a
testb %al, %al
je 0x62ed
movq (%rbx), %rax
cmpq $0x0, 0x38(%rax)
je 0x62da
cmpq $0x0, 0x18(%rax)
je 0x62da
movq %rbx, %rdi
callq 0x63dc
jmp 0x62e2
xorl %eax, %eax
jmp 0x62e4
movq %rbx, %rdi
callq 0x632a
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x45c0
movsd %xmm0, -0x18(%rbp)
movq (%rbx), %rdi
callq 0x45c0
ucomisd -0x18(%rbp), %xmm0
jbe 0x6313
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x631e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11e0
addq $0x18, %rdi
movq %r14, %rsi
callq 0x628c
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x4210
movq $0x0, -0x8(%rbx)
movq (%r14), %rax
leaq 0x18(%rax), %rsi
cmpq $0x0, 0x38(%rax)
movq 0x18(%rax), %rcx
je 0x636b
addq $0x38, %rax
testq %rcx, %rcx
cmoveq %rax, %rsi
jmp 0x6370
testq %rcx, %rcx
je 0x63a5
leaq -0x30(%rbp), %rdi
callq 0x5bcc
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x5bcc
cmpq $0x0, -0x30(%rbp)
je 0x6394
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x43b2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq $0x0, (%r14)
addq $0x8, %r14
movq %r14, %rdi
callq 0x43b2
jmp 0x6385
movq %rax, %r14
cmpq $0x0, -0x30(%rbp)
je 0x63cc
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x43b2
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6419
movq %rax, %r14
movq 0x38(%rax), %rax
testq %rax, %rax
jne 0x63f2
movq %r14, %rsi
callq 0x43e4
movq (%rbx), %rdi
addq $0x18, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x628c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x648d
movq %rbx, %rdi
callq 0x45c0
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x45c0
ucomisd -0x20(%rbp), %xmm0
jbe 0x6463
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x649b
movq %rbx, %rdi
callq 0x45c0
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x45c0
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x648d
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x64a1
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x18, %rdi
jmp 0x64a5
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x605e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6506
leaq 0x18(%rbx), %rdi
callq 0x64d4
movl %eax, %r14d
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x64d4
cmpl %eax, %r14d
cmovgl %r14d, %eax
incl %eax
jmp 0x6508
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x658b
leaq 0x18(%r15), %rbx
movq %rbx, %rdi
callq 0x654e
movl %eax, %r14d
leaq 0x38(%r15), %rdi
callq 0x654e
addl %r14d, %eax
cmpq $0x0, 0x38(%r15)
jne 0x658d
cmpq $0x1, (%rbx)
adcl $0x0, %eax
jmp 0x658d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x650e
movq %rbx, %rdi
movl %eax, %esi
callq 0x4718
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5c36
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4922
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x46f0
cmpq $0x0, (%r14)
je 0x66f7
movq %r14, %rdi
xorl %esi, %esi
callq 0x650e
movq %rbx, %rdi
movl %eax, %esi
callq 0x4bd6
leaq -0x14(%rbp), %rdx
movl $0x1, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5d4e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x6705
movq %rax, %r14
movq %rbx, %rdi
callq 0x4922
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5f10
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x6598
movl $0x1, %r14d
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x4b7e
cmpl %eax, %r14d
jg 0x676e
movq %r15, %rdi
movl %r14d, %esi
callq 0x4af8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61fe
incl %r14d
jmp 0x6746
leaq -0x40(%rbp), %rdi
callq 0x4922
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x6796
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x4922
cmpq $0x0, (%rbx)
je 0x67a3
movq $0x0, (%rbx)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x43b2
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6598
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x4210
movq $0x0, (%rbx)
movl $0x1, %r12d
leaq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0x4b7e
cmpl %eax, %r12d
jg 0x683d
movq %r13, %rdi
movl %r12d, %esi
callq 0x4af8
cmpq $0x0, (%r15)
je 0x6822
movq %r15, %rdi
movq %rax, %rsi
callq 0x641e
testb %al, %al
jne 0x6838
movq %r13, %rdi
movl %r12d, %esi
callq 0x4af8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61fe
incl %r12d
jmp 0x67f5
leaq -0x50(%rbp), %rdi
callq 0x4922
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x6875
movq %rax, %r15
cmpq $0x0, (%rbx)
je 0x686d
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x43b2
leaq -0x50(%rbp), %rdi
callq 0x4922
movq %r15, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e0c
leaq 0x38(%r14), %rsi
leaq 0x38(%rbx), %rdi
callq 0x6ea2
cmpq $0x0, 0x18(%r14)
je 0x6e20
leaq 0x18(%r14), %rsi
leaq 0x18(%rbx), %rdi
callq 0x6ea2
movl 0x58(%r14), %eax
movl %eax, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e8b
movq %rsi, %r14
movq %rbx, %rdi
callq 0x6e2c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6de6
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6ecf
movq %rsi, %r14
movq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
callq 0x43b2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7010
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x6f2d
movq %rdx, %rbx
movq %rsi, %r14
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6ed8
movq (%r15), %r12
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4af8
movq %rax, %rdi
movq %r12, %rsi
callq 0x43e4
incl (%rbx)
movq (%r15), %r15
movq 0x38(%r15), %rdi
addq $0x38, %r15
testq %rdi, %rdi
jne 0x6ef4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rdi), %r12
testq %r12, %r12
je 0x6f8b
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4af8
movq %rax, %rdi
movq %r12, %rsi
callq 0x43e4
incl (%rbx)
movq (%r15), %rdi
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6f36
movq (%r15), %r15
movq 0x38(%r15), %r12
addq $0x38, %r15
testq %r12, %r12
jne 0x6f52
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6fe4
movq %rdx, %rbx
movq %rsi, %r14
addq $0x18, %rdi
callq 0x6f94
movq (%r15), %rdi
addq $0x38, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6f94
movq (%r15), %r15
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4af8
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_O3/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 0x7096
movq %rsi, %rbx
movl $0x60, %edi
callq 0x10f0
movq %rax, %r15
movq %rax, %rdi
callq 0x6ce4
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 0x7010
movq (%r14), %rdi
addq $0x38, %rdi
movq (%rbx), %rsi
addq $0x38, %rsi
callq 0x7010
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_O3/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, %r14
movq (%rdi), %rsi
movb $0x1, %bl
testq %rsi, %rsi
je 0x716f
movq %rdi, %r15
cmpq $0x0, (%r14)
je 0x716d
movq %r14, %rdi
callq 0x759a
testb %al, %al
je 0x716d
movq (%r15), %rdi
addq $0x18, %rdi
movq %r14, %rsi
callq 0x711c
testb %al, %al
je 0x716d
movq (%r15), %r15
movq 0x38(%r15), %rsi
addq $0x38, %r15
testq %rsi, %rsi
jne 0x7136
jmp 0x716f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x718c
popq %rbp
jmp 0x759a
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x762a
movl %eax, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x762a
cmpl %eax, %r15d
jne 0x71ce
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x711c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45c0
cvtsi2sdl (%rbx), %xmm1
ucomisd %xmm1, %xmm0
jne 0x721b
jnp 0x726e
movsd %xmm0, -0x28(%rbp)
movq (%r14), %rdi
movsd %xmm1, -0x18(%rbp)
callq 0x45c0
ucomisd -0x18(%rbp), %xmm0
movq (%r14), %rdi
jbe 0x723e
cmpq $0x0, 0x18(%rdi)
jne 0x7284
xorps %xmm0, %xmm0
cvtsi2sdl (%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x45c0
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
jbe 0x726e
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x728a
cmpneqsd %xmm1, %xmm0
movq %xmm0, %rax
andl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x18, %rdi
jmp 0x728e
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x71f6
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45c0
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x45c0
ucomisd -0x18(%rbp), %xmm0
jbe 0x72d3
movq (%r14), %rax
leaq 0x18(%rax), %r14
cmpq $0x0, 0x18(%rax)
jne 0x72a7
jmp 0x7301
movq %rbx, %rdi
callq 0x45c0
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x45c0
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7304
movq (%r14), %rax
leaq 0x38(%rax), %r14
cmpq $0x0, 0x38(%rax)
jne 0x72a7
movq %rbx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x74bb
addq $0x18, %rdi
callq 0x73d6
movq (%rbx), %rdi
addq $0x38, %rdi
callq 0x73d6
movq (%rbx), %r13
leaq 0x38(%r13), %r14
movq %r14, %rdi
callq 0x74ca
movl %eax, %r15d
leaq 0x18(%r13), %r12
movq %r12, %rdi
callq 0x74ca
subl %eax, %r15d
movl %r15d, 0x58(%r13)
je 0x74bb
cmpl $-0x2, %r15d
je 0x745e
cmpl $0x2, %r15d
jne 0x74bb
movq (%r14), %rax
movl 0x58(%rax), %ecx
cmpl $0x1, %ecx
ja 0x7485
movq 0x18(%rax), %rcx
movq %rax, (%rbx)
movq %rcx, 0x38(%r13)
movq (%rbx), %rax
movq %r13, 0x18(%rax)
jmp 0x74bb
movq (%r12), %rax
movl 0x58(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl $0x2, %edx
jae 0x74a0
movq 0x38(%rax), %rcx
movq %rax, (%rbx)
movq %r13, 0x38(%rax)
movq (%rbx), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x74bb
cmpl $-0x1, %ecx
jne 0x74bb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7394
cmpl $0x1, %ecx
jne 0x74bb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7352
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x74fc
leaq 0x18(%rbx), %rdi
callq 0x74ca
movl %eax, %r14d
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x74ca
cmpl %eax, %r14d
cmovgl %r14d, %eax
incl %eax
jmp 0x74fe
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6ce4
movq %r14, %rdi
movq %r15, %rsi
callq 0x43e4
cmpq $0x0, (%rbx)
je 0x756d
movq %r15, %rdi
callq 0x45c0
cvttsd2si %xmm0, %eax
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x71f6
testb %al, %al
je 0x7574
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7296
movq %rbx, %rdi
callq 0x73d6
jmp 0x7570
movq %r14, (%rbx)
movb $0x1, %al
jmp 0x7576
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_O3/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 0x7609
movq %rbx, %rdi
callq 0x45c0
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x45c0
ucomisd -0x20(%rbp), %xmm0
jbe 0x75df
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x7617
movq %rbx, %rdi
callq 0x45c0
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x45c0
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7609
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x761d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x18, %rdi
jmp 0x7621
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x717c
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x76a7
leaq 0x18(%r15), %rbx
movq %rbx, %rdi
callq 0x766a
movl %eax, %r14d
leaq 0x38(%r15), %rdi
callq 0x766a
addl %r14d, %eax
cmpq $0x0, 0x38(%r15)
jne 0x76a9
cmpq $0x1, (%rbx)
adcl $0x0, %eax
jmp 0x76a9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x762a
movq %rbx, %rdi
movl %eax, %esi
callq 0x4718
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6f94
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4922
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7827
movq %rax, %r14
movq 0x38(%rax), %rax
testq %rax, %rax
jne 0x7800
movq %r14, %rsi
callq 0x43e4
movq (%rbx), %rdi
addq $0x18, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x782c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
leaq 0x18(%rax), %rsi
cmpq $0x0, 0x38(%rax)
movq 0x18(%rax), %rcx
je 0x7899
addq $0x38, %rax
testq %rcx, %rcx
cmoveq %rax, %rsi
jmp 0x789e
testq %rcx, %rcx
je 0x78cc
leaq -0x30(%rbp), %rdi
callq 0x6ea2
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x6ea2
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x43b2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq $0x0, (%r14)
addq $0x8, %r14
movq %r14, %rdi
callq 0x43b2
jmp 0x78b3
movq %rax, %r14
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x43b2
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7946
movq %rsi, %r14
movq %rdi, %rbx
callq 0x759a
testb %al, %al
je 0x7946
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x442a
testb %al, %al
je 0x795d
movq (%rbx), %rax
cmpq $0x0, 0x38(%rax)
je 0x794a
cmpq $0x0, 0x18(%rax)
je 0x794a
movq %rbx, %rdi
callq 0x77ea
jmp 0x7952
xorl %eax, %eax
jmp 0x7954
movq %rbx, %rdi
callq 0x7858
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x45c0
movsd %xmm0, -0x18(%rbp)
movq (%rbx), %rdi
callq 0x45c0
ucomisd -0x18(%rbp), %xmm0
jbe 0x7983
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x798e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x121d
addq $0x18, %rdi
movq %r14, %rsi
callq 0x782c
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x540, %rsp            # imm = 0x540
movq %rsi, %rbx
movl %edi, 0xc(%rsp)
leaq 0x2c(%rsp), %rdi
movl $0x104, %edx            # imm = 0x104
xorl %esi, %esi
callq 0x41b0
leaq 0x130(%rsp), %r14
movq %r14, %rdi
callq 0x7f00
leaq 0x10(%rsp), %rdx
movl $0x1, (%rdx)
movq %rsp, %r8
movl $0x78, (%r8)
leaq 0x22571(%rip), %rsi     # 0x27110
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x7f3a
leaq 0x10(%rsp), %rdx
movl $0x0, (%rdx)
movq %rsp, %r8
movl $0x68, (%r8)
leaq 0x2243f(%rip), %rsi     # 0x27004
leaq 0x130(%rsp), %rdi
xorl %ecx, %ecx
callq 0x7f3a
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x130(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movq %rbx, %rdx
callq 0x7f70
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r12
cmpq %r12, %r15
je 0x4c6d
xorl %ebp, %ebp
leaq 0x30(%rsp), %r14
movl (%r15), %eax
cmpl $0x68, %eax
je 0x4c2d
cmpl $0x78, %eax
jne 0x4c3a
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x42c0
jmp 0x4c3a
movl $0x1, 0x2c(%rsp)
movl $0x1, %ebp
addq $0x28, %r15
cmpq %r12, %r15
jne 0x4c12
testl %ebp, %ebp
jg 0x4c6d
cmpb $0x0, 0x30(%rsp)
je 0x4c6d
movq %rsp, %rdi
callq 0x8428
movq %rsp, %rdi
leaq 0x2c(%rsp), %rsi
callq 0x8440
movq %rsp, %rdi
callq 0x8434
jmp 0x4c75
movq (%rbx), %rdi
callq 0x7df8
leaq 0x10(%rsp), %rdi
callq 0x4cd6
leaq 0x130(%rsp), %rdi
callq 0x7f1a
xorl %eax, %eax
addq $0x540, %rsp            # imm = 0x540
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8434
jmp 0x4cb7
jmp 0x4cb4
jmp 0x4caf
movq %rax, %rbx
jmp 0x4cc1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4cd6
leaq 0x130(%rsp), %rdi
callq 0x7f1a
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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, (%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x78(%rsi), %rax
cmpq %rax, 0x80(%rsi)
je 0x500d
movq %rsi, %r15
movl $0x1, %r12d
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 0x5c26
movq (%rsp), %rax
movq 0x8(%rax), %rdx
cmpq 0x10(%rsp), %rdx
jne 0x4f95
movq 0x8(%rsp), %rbp
testq %rdx, %rdx
je 0x4f9f
movq (%rsp), %rax
movq (%rax), %rdi
movq %rbp, %rsi
callq 0x4300
testl %eax, %eax
sete %r14b
jmp 0x4fa2
movq 0x8(%rsp), %rbp
xorl %r14d, %r14d
jmp 0x4fa2
movb $0x1, %r14b
leaq 0x18(%rsp), %rax
cmpq %rax, %rbp
je 0x4fbc
movq 0x18(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x42f0
testb %r14b, %r14b
je 0x4fec
shlq $0x3, %r13
addq 0x78(%r15), %r13
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4fe1
movq (%r13), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4fec
movq %rbx, %rdi
movq %r13, %rdx
callq 0x603a
movl %r12d, %r13d
movq 0x78(%r15), %rax
movq 0x80(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %r12d
cmpq %r13, %rcx
ja 0x4f42
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5021
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5038
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x42f0
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x508b
xorl %ebp, %ebp
movl $0x2d, %edi
callq 0x4400
incl %ebp
movl (%rbx), %eax
addl %eax, %eax
cmpl %eax, %ebp
jb 0x5077
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 0x5c26
movq (%r12), %rsi
leaq 0x21f52(%rip), %rdi     # 0x27009
xorl %eax, %eax
callq 0x4050
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x50d4
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42f0
leaq 0x78(%r15), %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x5b8a
movq (%r12), %rax
cmpq 0x8(%r12), %rax
je 0x5145
movl $0xa, %edi
callq 0x4400
movq (%rsp), %rdi
cmpq %rdi, 0x8(%rsp)
je 0x518b
movl $0x1, %ebp
xorl %eax, %eax
leaq 0x18(%rsp), %r15
movq (%rdi,%rax,8), %rsi
movl (%rbx), %eax
incl %eax
movl %eax, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0x5056
movl %ebp, %eax
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x5113
jmp 0x518b
leaq 0x18(%rsp), %rdi
movq %r13, (%rdi)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
callq 0x5c26
movq 0x18(%rsp), %rsi
leaq 0x21ea3(%rip), %rdi     # 0x2700c
xorl %eax, %eax
callq 0x4050
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x5187
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42f0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x519d
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 0x51ae
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x51c7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
nop