LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7de0
testb $0x1, %al
jne 0x7f96
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x5c50
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x5150
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7f10
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7f10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7de0
testb $0x1, %al
jne 0x8026
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7fa0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7fa0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x5c50
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x5150
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x9300
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x9330
jmp 0x8077
jmp 0x8079
leaq -0x70(%rbp), %rdi
callq 0x9360
movb %al, -0x91(%rbp)
jmp 0x808a
movb -0x91(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x809b
jmp 0x81a8
leaq -0x70(%rbp), %rdi
callq 0x9380
movq %rax, -0xa0(%rbp)
jmp 0x80ad
movq -0xa0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9380
movq %rax, -0xa8(%rbp)
jmp 0x80cd
movq -0xa8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x5c50
movq %rax, -0xb0(%rbp)
jmp 0x80f6
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
callq 0x5150
jmp 0x810b
movq -0x18(%rbp), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
leaq -0x70(%rbp), %rdi
callq 0x93a0
jmp 0x8120
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x7de0
movb %al, -0xb9(%rbp)
jmp 0x8135
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x816d
jmp 0x8141
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
leaq -0x70(%rbp), %rdi
callq 0x9330
jmp 0x8154
jmp 0x816d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x93c0
jmp 0x81ba
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x7de0
movb %al, -0xba(%rbp)
jmp 0x8182
movb -0xba(%rbp), %al
testb $0x1, %al
jne 0x81a3
jmp 0x818e
movq -0x20(%rbp), %rsi
addq $0x38, %rsi
leaq -0x70(%rbp), %rdi
callq 0x9330
jmp 0x81a1
jmp 0x81a3
jmp 0x8079
leaq -0x70(%rbp), %rdi
callq 0x93c0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8314
movl $0x58, %edi
callq 0x10e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x7bf0
jmp 0x82a1
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdi
callq 0x5150
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
callq 0x8260
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x38, %rsi
callq 0x8260
jmp 0x831f
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x10f0
jmp 0x8325
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7de0
testb $0x1, %al
jne 0x83d3
jmp 0x83d9
movb $0x1, -0x1(%rbp)
jmp 0x8438
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
callq 0x8450
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x83f7
jmp 0x8430
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x83b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x8419
jmp 0x8430
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x83b0
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7de0
testb $0x1, %al
jne 0x8473
jmp 0x8479
movb $0x0, -0x1(%rbp)
jmp 0x848b
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8b20
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x8500
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8500
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jne 0x84e6
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x83b0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x84ea
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
callq 0x5430
movq -0x18(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x85a9
jp 0x85a9
movb $0x0, -0x1(%rbp)
jmp 0x8654
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cvtsi2sdl (%rcx), %xmm0
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rdi
callq 0x5430
movsd -0x28(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x85f7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x85f7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x8570
jmp 0x8650
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cvtsi2sdl (%rcx), %xmm0
movsd %xmm0, -0x30(%rbp)
movq (%rax), %rdi
callq 0x5430
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8648
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x8648
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x8570
jmp 0x864e
movb $0x1, -0x1(%rbp)
jmp 0x8654
jmp 0x8650
jmp 0x8652
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
movq (%rax), %rdi
callq 0x5430
movsd -0x18(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x86d8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x86c7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x8660
jmp 0x86d6
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x873d
movq -0x10(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rdi
callq 0x5430
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x873b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x872a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x8660
jmp 0x8739
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x38(%rax)
jmp 0x873b
jmp 0x873d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x58, %edi
callq 0x10e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x7bf0
jmp 0x8783
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x5150
movq -0x40(%rbp), %rdi
callq 0x7de0
testb $0x1, %al
jne 0x87a7
jmp 0x87d4
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x8810
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x58, %esi
callq 0x10f0
jmp 0x881b
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x40(%rbp), %rdi
cvttsd2si %xmm0, %eax
movl %eax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x8570
testb $0x1, %al
jne 0x87f7
jmp 0x880a
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8660
movb $0x1, -0x1(%rbp)
jmp 0x8810
jmp 0x880c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7de0
testb $0x1, %al
jne 0x8981
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8450
testb $0x1, %al
jne 0x886b
jmp 0x8981
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5190
testb $0x1, %al
jne 0x8881
jmp 0x88dc
movq -0x20(%rbp), %rdi
callq 0x8520
testb $0x1, %al
jne 0x88b8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x88b8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x88b8
jmp 0x88ca
movq -0x20(%rbp), %rdi
callq 0x89a0
movb $0x1, -0x1(%rbp)
jmp 0x8989
movq -0x20(%rbp), %rdi
callq 0x8a90
movb $0x1, -0x1(%rbp)
jmp 0x8989
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rdi
callq 0x5430
movsd -0x28(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x892b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x892b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x8830
jmp 0x897d
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movq (%rax), %rdi
callq 0x5430
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x897b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x897b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x8830
jmp 0x897d
jmp 0x897f
jmp 0x8987
movb $0x0, -0x1(%rbp)
jmp 0x8989
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x81d0
movq -0x40(%rbp), %rdi
callq 0x8520
testb $0x1, %al
jne 0x89cc
jmp 0x89da
movq -0x40(%rbp), %rdi
callq 0x8330
jmp 0x8a6b
movq -0x40(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x8a2c
movq -0x40(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
leaq -0x28(%rbp), %rdi
callq 0x7e00
jmp 0x8a04
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7e00
jmp 0x8a13
jmp 0x8a69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8330
jmp 0x8a7a
movq -0x40(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x8a67
movq -0x40(%rbp), %rax
movq (%rax), %rsi
addq $0x38, %rsi
leaq -0x28(%rbp), %rdi
callq 0x7e00
jmp 0x8a56
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7e00
jmp 0x8a65
jmp 0x8a67
jmp 0x8a69
jmp 0x8a6b
leaq -0x28(%rbp), %rdi
callq 0x8330
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x8b18
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x7de0
xorb $-0x1, %al
testb $0x1, %al
jne 0x8ae6
jmp 0x8af4
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8ad1
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rsi
movq (%rax), %rdi
callq 0x5150
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x8830
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5190
testb $0x1, %al
jne 0x8b4a
jmp 0x8b53
movb $0x1, -0x1(%rbp)
jmp 0x8c00
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rdi
callq 0x5430
movsd -0x28(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8ba2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x8ba2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x8450
jmp 0x8bfc
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movq (%rax), %rdi
callq 0x5430
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8bf4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x8bf4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x8450
jmp 0x8bfa
movb $0x0, -0x1(%rbp)
jmp 0x8c00
jmp 0x8bfc
jmp 0x8bfe
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x7de0
testb $0x1, %al
jne 0x8c4e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x5020
jmp 0x8c5f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x5020
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7de0
testb $0x1, %al
jne 0x8cd6
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x8c70
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x8c70
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x8cc5
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x8ccb
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8cdd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x7de0
testb $0x1, %al
jne 0x8dd8
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x8d60
movl -0x20(%rbp), %ecx
movl %eax, %edx
movq -0x18(%rbp), %rax
addl %edx, %ecx
movl %ecx, -0x1c(%rbp)
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x8d60
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
callq 0x8520
testb $0x1, %al
jne 0x8dcd
jmp 0x8dd6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8dd8
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x1, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x8500
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x5660
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x7e80
jmp 0x8e41
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x8e6d
jmp 0x8e64
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5970
jmp 0x8e77
movq -0x30(%rbp), %rdi
callq 0x5970
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
// File: jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Preorden() const
TVectorPoro TABBPoro::Preorden() 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());
	PreordenAux(v, posicion);
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x1, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x8500
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x5660
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x7f10
jmp 0x8ed1
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x8efd
jmp 0x8ef4
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5970
jmp 0x8f07
movq -0x30(%rbp), %rdi
callq 0x5970
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
// File: jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Postorden() const
TVectorPoro TABBPoro::Postorden() const {
	//Posición en el vector que almacena el recorrido
	int posicion = 1;
	//Vector del tamaño adecuado para almacenar todos los nodos
	TVectorPoro v(Nodos());
	PostordenAux(v, posicion);
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x1, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x8500
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x5660
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x7fa0
jmp 0x8f61
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x8f8d
jmp 0x8f84
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5970
jmp 0x8f97
movq -0x30(%rbp), %rdi
callq 0x5970
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
// File: jespinosa94[P]PED16/lib/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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5620
movq -0x30(%rbp), %rdi
callq 0x7de0
testb $0x1, %al
jne 0x9028
movq -0x30(%rbp), %rdi
callq 0x8500
movl %eax, -0x44(%rbp)
jmp 0x8fe7
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %rdi
callq 0x5dd0
jmp 0x8ff5
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
movl $0x1, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x8030
jmp 0x900f
jmp 0x9028
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5970
jmp 0x9045
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x903b
movq -0x40(%rbp), %rdi
callq 0x5970
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0x8200
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x8df0
jmp 0x908e
movl $0x1, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5d50
movl %eax, -0x6c(%rbp)
jmp 0x90a9
movl -0x70(%rbp), %eax
movl -0x6c(%rbp), %ecx
cmpl %ecx, %eax
jg 0x9106
movl -0x58(%rbp), %esi
leaq -0x48(%rbp), %rdi
callq 0x5c50
movq %rax, -0x78(%rbp)
jmp 0x90c5
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x8750
jmp 0x90d4
jmp 0x90d6
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x9095
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x912f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5970
jmp 0x912f
movb $0x1, -0x19(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5970
testb $0x1, -0x19(%rbp)
jne 0x9122
movq -0x68(%rbp), %rdi
callq 0x8330
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x8330
movq -0x50(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8df0
movq -0x60(%rbp), %rdi
movb $0x0, -0x41(%rbp)
callq 0x81d0
jmp 0x918e
movl $0x1, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5d50
movl %eax, -0x6c(%rbp)
jmp 0x91a9
movl -0x70(%rbp), %eax
movl -0x6c(%rbp), %ecx
cmpl %ecx, %eax
jg 0x9250
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x58(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x5c50
movq %rax, -0x78(%rbp)
jmp 0x91d1
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x8450
movb %al, -0x81(%rbp)
jmp 0x91e6
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x9240
jmp 0x91f2
movl -0x58(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x5c50
movq %rax, -0x90(%rbp)
jmp 0x9207
movq -0x90(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x8750
jmp 0x9219
jmp 0x9240
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x9279
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x8330
jmp 0x9279
jmp 0x9242
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x9195
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x9263
movq -0x60(%rbp), %rdi
callq 0x8330
leaq -0x40(%rbp), %rdi
callq 0x5970
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x5970
movq -0x50(%rbp), %rdi
callq 0x1180
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5150
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0xab20
testb $0x1, %al
jne 0xaa57
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0xab40
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xab20
testb $0x1, %al
jne 0xaa7d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0xab40
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x58(%rcx), %ecx
movl %ecx, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0xab14
movq -0x18(%rbp), %rdi
callq 0xaaa0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xaa10
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0xab74
movq -0x18(%rbp), %rdi
callq 0xaec0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xad60
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xab20
testb $0x1, %al
jne 0xac06
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xab80
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x5c50
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x5150
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xab80
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xab20
testb $0x1, %al
jne 0xac96
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x5c50
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x5150
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xac10
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xac10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xab20
testb $0x1, %al
jne 0xad26
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xaca0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xaca0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x5c50
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x5150
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xab20
testb $0x1, %al
jne 0xae3d
movl $0x60, %edi
callq 0x10e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0xa8d0
jmp 0xada4
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdi
callq 0x5150
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl 0x58(%rcx), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x58(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
callq 0xad60
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x38, %rsi
callq 0xad60
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x5150
jmp 0xae48
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x10f0
jmp 0xae4e
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xab20
testb $0x1, %al
jne 0xaf13
jmp 0xaf19
movb $0x1, -0x1(%rbp)
jmp 0xaf78
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
callq 0xaf90
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0xaf37
jmp 0xaf70
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0xaef0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0xaf59
jmp 0xaf70
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0xaef0
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xab20
testb $0x1, %al
jne 0xafb3
jmp 0xafb9
movb $0x0, -0x1(%rbp)
jmp 0xafcb
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb650
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xb040
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb040
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jne 0xb026
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaef0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb02a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tavlporo.cpp
// Function: TAVLPoro::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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
callq 0x5430
movq -0x18(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0xb0c9
jp 0xb0c9
movb $0x0, -0x1(%rbp)
jmp 0xb174
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cvtsi2sdl (%rcx), %xmm0
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rdi
callq 0x5430
movsd -0x28(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xb117
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xab20
testb $0x1, %al
jne 0xb117
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0xb090
jmp 0xb170
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cvtsi2sdl (%rcx), %xmm0
movsd %xmm0, -0x30(%rbp)
movq (%rax), %rdi
callq 0x5430
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb168
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0xab20
testb $0x1, %al
jne 0xb168
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0xb090
jmp 0xb16e
movb $0x1, -0x1(%rbp)
jmp 0xb174
jmp 0xb170
jmp 0xb172
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
movq (%rax), %rdi
callq 0x5430
movsd -0x18(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xb1f8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xab20
testb $0x1, %al
jne 0xb1e7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0xb180
jmp 0xb1f6
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0xb25d
movq -0x10(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rdi
callq 0x5430
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb25b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0xab20
testb $0x1, %al
jne 0xb24a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0xb180
jmp 0xb259
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x38(%rax)
jmp 0xb25b
jmp 0xb25d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq 0x38(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rcx
movq 0x38(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x38(%rcx)
movq -0x10(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdx
movq (%rax), %rcx
movq %rdx, 0x38(%rcx)
movq -0x20(%rbp), %rcx
movq (%rax), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xab20
testb $0x1, %al
jne 0xb4e7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xb370
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0xb370
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0xb4f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xb4f0
movl -0x14(%rbp), %edx
movl %eax, %ecx
movq -0x10(%rbp), %rax
subl %ecx, %edx
movq (%rax), %rcx
movl %edx, 0x58(%rcx)
movq (%rax), %rax
cmpl $-0x1, 0x58(%rax)
je 0xb4e5
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x58(%rax)
je 0xb4e5
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x58(%rax)
je 0xb4e5
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, 0x58(%rax)
jne 0xb453
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
cmpl $0x1, 0x58(%rax)
je 0xb445
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
cmpl $0x0, 0x58(%rax)
jne 0xb453
movq -0x10(%rbp), %rdi
callq 0xb270
jmp 0xb4e3
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $-0x2, 0x58(%rax)
jne 0xb48d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpl $-0x1, 0x58(%rax)
je 0xb482
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x58(%rax)
jne 0xb48d
movq -0x10(%rbp), %rdi
callq 0xb2c0
jmp 0xb4e1
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $-0x2, 0x58(%rax)
jne 0xb4b6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpl $0x1, 0x58(%rax)
jne 0xb4b6
movq -0x10(%rbp), %rdi
callq 0xb310
jmp 0xb4df
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, 0x58(%rax)
jne 0xb4dd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
cmpl $-0x1, 0x58(%rax)
jne 0xb4dd
movq -0x10(%rbp), %rdi
callq 0xb340
jmp 0xb4df
jmp 0xb4e1
jmp 0xb4e3
jmp 0xb4e5
jmp 0xb4e7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xab20
testb $0x1, %al
jne 0xb556
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xb4f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq (%rax), %rdi
addq $0x38, %rdi
callq 0xb4f0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xb545
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xb54b
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb55d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)