LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::liberarMemoria()
void ed::NodoEnlazadoArbolBinarioEstudiante::liberarMemoria(){
	if(hasLeftTree()){ //Liberamos la memoria del subárbol hijo izquierdo
		getLeftTree()->liberarMemoria();
	}
			
	if(hasRightTree()){ //Liberamos la memoria del subárbol hijo derecho
		getRightTree()->liberarMemoria();
	}
	
	//Borramos los atributos del nodo raíz
	delete _item;
	delete getLeftTree();
	delete getRightTree();
		
	_item=NULL;
	setLeftTree(NULL);
	setRightTree(NULL);
	setParent(NULL);
	
	//Postcondición
	#ifndef NDEBUG
		assert(isEmpty());
	#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2c6e
callq 0x2c5c
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2c7c
callq 0x2c5c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2c8b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2c9a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0x2cad
movq (%rdi), %rax
callq *0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::nItems() const
int ed::NodoEnlazadoArbolBinarioEstudiante::nItems() const{
	int items=0;

	if(!isEmpty()){
		items++; //Sumamos el ítem del nodo raíz

		if(hasLeftTree()){
			items=items+getLeftTree()->nItems(); //Sumamos los ítems de su subárbol hijo izquierdo
		}

		if(hasRightTree()){
			items=items+getRightTree()->nItems(); //Sumamos los ítems de su subárbol hijo derecho
		}
	}

	return items;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebp, %ebp
xorl %ebx, %ebx
cmpq $0x0, 0x8(%r14)
je 0x2cf2
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x2cde
callq 0x2cba
incl %eax
jmp 0x2ce3
movl $0x1, %eax
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x2cf0
addl %eax, %ebx
jmp 0x2cc5
movl %eax, %ebp
addl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::exists(ed::Estudiante const&)
bool ed::NodoEnlazadoArbolBinarioEstudiante::exists(ed::Estudiante const &item){
	if(isEmpty()){
		return false; //Si el árbol está vacío, es imposible que exista el ítem
	}

	else{ //El árbol no está vacío
		if(getItem()==item){ //El nodo raíz contiene el ítem que buscamos
			return true;
		}

		else{ //El nodo raíz no contiene el ítem que buscamos
			if(item<getItem()){ //El ítem ha de encontrarse a la izquierda del árbol
				if(hasLeftTree()){
					return getLeftTree()->exists(item); //Buscamos el ítem en el subárbol hijo izquierdo
				}

				else{
					return false;
				}
			}

			else{ //El ítem ha de encontrarse a la derecha del árbol
				if(hasRightTree()){
					return getRightTree()->exists(item); //Buscamos el ítem en el subárbol hijo derecho
				}

				else{
					return false;
				}
			}
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%r14)
je 0x2d4c
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x29a0
testb %al, %al
jne 0x2d50
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a28
testb %al, %al
je 0x2d43
movq 0x10(%r14), %r14
jmp 0x2d47
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x2d06
xorl %eax, %eax
jmp 0x2d52
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(ed::Estudiante const&)
ed::Estudiante const &ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(ed::Estudiante const & item){
	//Precondición
	#ifndef NDEBUG
		assert(exists(item));
	#endif

	if(getItem()==item){ //El nodo raíz contiene el ítem que buscamos
		return getItem();
	}

	else{
		if(item<getItem()){ //El ítem está a la izquierda
			return getLeftTree()->getEstudiante(item); //Buscamos el ítem en el subárbol hijo izquierdo
		}

		else{ //El ítem está a la derecha
			return getRightTree()->getEstudiante(item); //Buscamos el ítem en el subárbol hijo derecho
		}
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2cfc
testb %al, %al
je 0x2db3
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x29a0
movl %eax, %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %bpl, %bpl
jne 0x2dae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a28
xorb $0x1, %al
movzbl %al, %eax
movq 0x10(%r14,%rax,8), %r14
jmp 0x2d64
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6525(%rip), %rdi      # 0x92df
leaq 0x6374(%rip), %rsi      # 0x9135
leaq 0x6394(%rip), %rcx      # 0x915c
movl $0x5f, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(int)
ed::Estudiante const &ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(int indice){
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty() and indice<=nItems());
	#endif

	if(hasLeftTree()){ //El nodo raíz tiene un subárbol hijo izquierdo
		if(indice==getLeftTree()->nItems()){ //El ítem está en el nodo raíz
			return getItem();
		}

		else if(indice<getLeftTree()->nItems()){ //El ítem está a la izquierda
			return getLeftTree()->getEstudiante(indice); //Buscamos el ítem en el subárbol hijo izquierdo
		}

		else{ //El ítem está a la derecha
			return getRightTree()->getEstudiante(indice-(getLeftTree()->nItems()+1)); //Buscamos el ítem en el subárbol hijo derecho
		}
	}

	else{ //El nodo raíz no tiene un subárbol hijo izquierdo
		if(indice==0){ //El ítem está en el nodo raíz
			return getItem();
		}

		else{ //El ítem está a la derecha
			return getRightTree()->getEstudiante(indice-1); //Buscamos el ítem en el subárbol hijo derecho
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
cmpq $0x0, 0x8(%r15)
je 0x2e2d
movq %r15, %r14
movq %r15, %rdi
callq 0x2cba
cmpl %ebx, %eax
jl 0x2e2d
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x2e13
movq %r15, %rdi
callq 0x2cba
cmpl %ebx, %eax
je 0x2e1f
jg 0x2ddc
movq 0x18(%r14), %r15
notl %eax
addl %eax, %ebx
jmp 0x2ddc
testl %ebx, %ebx
je 0x2e1f
movq 0x18(%r14), %r15
decl %ebx
jmp 0x2ddc
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x10(%rax)
leaq 0x638c(%rip), %rdi      # 0x91c0
leaq 0x62fa(%rip), %rsi      # 0x9135
leaq 0x639e(%rip), %rcx      # 0x91e0
movl $0x74, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::getMinor() const
ed::Estudiante const &ed::NodoEnlazadoArbolBinarioEstudiante::getMinor() const{
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty());
	#endif

	if(hasLeftTree()){ //El nodo raíz tiene un subárbol hijo izquierdo
		return getLeftTree()->getMinor();
	}

	else{ //El nodo raíz no tiene un subárbol hijo izquierdo, por lo tanto, es el que contiene el ítem menor
		return getItem();
	}
}

// Assembly:
pushq %rax
movq %rdi, %rax
cmpq $0x0, 0x8(%rax)
je 0x2e6a
movq %rax, %rdi
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x2e50
movq (%rdi), %rax
popq %rcx
jmpq *0x10(%rax)
leaq 0x63c0(%rip), %rdi      # 0x9231
leaq 0x62bd(%rip), %rsi      # 0x9135
leaq 0x63bd(%rip), %rcx      # 0x923c
movl $0x93, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::setEstudiante(ed::Estudiante const&)
void ed::NodoEnlazadoArbolBinarioEstudiante::setEstudiante(ed::Estudiante const &item){
	//Precondición
	#ifndef NDEBUG
		assert(exists(item));
	#endif

	if(item==getItem()){ //El nodo raíz contiene el ítem a modificar
		setItem(item); //Modificamos el ítem
	}
	
	else if(item<getItem()){ //El ítem es menor que el ítem del nodo actual
		getLeftTree()->setEstudiante(item); //Buscamos el ítem en el subárbol hijo izquierdo
	}
	
	else{ //El item es mayor que el item del nodo actual
		getRightTree()->setEstudiante(item); //Buscamos el ítem en el subárbol hijo derecho
	}

	//Postcondición
	#ifndef NDEBUG
		assert(exists(item));
	#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2cfc
testb %al, %al
je 0x2efe
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29a0
movq (%r14), %rcx
movq %r14, %rdi
testb %al, %al
je 0x2ec3
movq %rbx, %rsi
callq *0x18(%rcx)
jmp 0x2ee7
callq *0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a28
testb %al, %al
je 0x2edb
movq 0x10(%r14), %rdi
jmp 0x2edf
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x2e8a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2cfc
testb %al, %al
je 0x2f1d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x63da(%rip), %rdi      # 0x92df
leaq 0x6229(%rip), %rsi      # 0x9135
leaq 0x6378(%rip), %rcx      # 0x928b
movl $0xa2, %edx
callq 0x20f0
leaq 0x63bb(%rip), %rdi      # 0x92df
leaq 0x620a(%rip), %rsi      # 0x9135
leaq 0x6359(%rip), %rcx      # 0x928b
movl $0xb3, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::inorder()
void ed::NodoEnlazadoArbolBinarioEstudiante::inorder(){
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty());
	#endif

	if(hasLeftTree()){ //El nodo actual tiene hijo izquierdo
		getLeftTree()->inorder(); //Escribimos inorden el subárbol hijo izquierdo
	}

	getItem().escribirEstudiante(); //Escribimos el ítem del nodo actual
	std::cout << std::endl;

	if(hasRightTree()){ //El nodo actual tiene hijo derecho
		getRightTree()->inorder(); //Escribimos inorden el subárbol hijo derecho
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x9c6a(%rip), %r14      # 0xcfd0
cmpq $0x0, 0x8(%rbx)
je 0x33c4
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x337b
callq 0x3358
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %rax, %rdi
callq 0x2600
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x3366
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5e66(%rip), %rdi      # 0x9231
leaq 0x5d63(%rip), %rsi      # 0x9135
leaq 0x5fb6(%rip), %rcx      # 0x938f
movl $0x166, %edx            # imm = 0x166
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::grabar(std::basic_ofstream<char, std::char_traits<char>>&)
void ed::NodoEnlazadoArbolBinarioEstudiante::grabar(std::ofstream &fichero){
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty());
	#endif

	fichero << getItem(); //Grabamos el ítem del nodo actual

	if(hasLeftTree()){ //El nodo actual tiene hijo izquierdo
		getLeftTree()->grabar(fichero); //Grabamos los ítems del subárbol hijo izquierdo
	}

	if(hasRightTree()){ //El nodo actual tiene hijo derecho
		getRightTree()->grabar(fichero); //Grabamos los ítems del subárbol hijo derecho
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%r14)
je 0x342b
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2b57
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x341a
movq %rbx, %rsi
callq 0x33e4
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x33ee
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5dff(%rip), %rdi      # 0x9231
leaq 0x5cfc(%rip), %rsi      # 0x9135
leaq 0x5f86(%rip), %rcx      # 0x93c6
movl $0x178, %edx            # imm = 0x178
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::~Estudiante()
~Estudiante(){
		this->setNombre("");
		this->setApellidos("");

		this->setTeoria(0.0);
		this->setPractica(0.0);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x977d(%rip), %rax      # 0xcca8
movq %rax, (%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x62e3(%rip), %rdx      # 0x9821
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x38b8
movq (%rbx), %rax
movq %rsp, %rsi
movq %rbx, %rdi
callq *0x30(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3563
callq 0x2140
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x62b1(%rip), %rdx      # 0x9821
movq %rdx, %rsi
callq 0x38b8
movq (%rbx), %rax
movq %rsp, %rsi
movq %rbx, %rdi
callq *0x38(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3592
callq 0x2140
movq %rsp, %rsi
movl $0x0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movq %rsp, %rsi
movl $0x0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x35c8
callq 0x2140
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x35da
callq 0x2140
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x35ff
jmp 0x35ff
jmp 0x35ec
jmp 0x35ff
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3602
callq 0x2140
jmp 0x3602
movq %rax, %r14
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x3614
callq 0x2140
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x3626
callq 0x2140
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./nodoEnlazadoArbolBinarioEstudiante.hpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::setItem(ed::Estudiante const&)
inline void setItem(ed::Estudiante const & nuevoItem){
			//Si el ítem actual es nulo
			if (this->_item == NULL){
				//Se reserva memoria y se copia el nuevo ítem
				this->_item = new Estudiante(nuevoItem);
			}

			//Si ya se ha reservado memoria para ítem
			else{
				//Se copia el nuevo ítem en el ítem actual
				*(this->_item) = nuevoItem;
			}
			
			//Postcondición
			#ifndef NDEBUG
				assert(getItem()==nuevoItem);
			#endif
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x36ca
movq %rbx, %rsi
callq 0x28f2
jmp 0x36e6
movl $0x50, %edi
callq 0x2160
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x344a
movq %r15, 0x8(%r14)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x29a0
testb %al, %al
je 0x3704
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5d98(%rip), %rdi      # 0x94a3
leaq 0x5cf9(%rip), %rsi      # 0x940b
leaq 0x5d9f(%rip), %rcx      # 0x94b8
movl $0x124, %edx            # imm = 0x124
callq 0x20f0
movq %rax, %rbx
movq %r15, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::setNombre(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void setNombre(const std::string & nombre){
		this->_nombre = nombre;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getNombre()==nombre);
		#endif
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x20c0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x8(%rax), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x37be
testq %rdx, %rdx
je 0x37b6
movq (%rbx), %rsi
movq (%rax), %rdi
callq 0x2170
testl %eax, %eax
jne 0x37be
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5d48(%rip), %rdi      # 0x950d
leaq 0x5d55(%rip), %rsi      # 0x9521
leaq 0x5d5f(%rip), %rcx      # 0x9532
movl $0xa4, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::setApellidos(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void setApellidos(const std::string & apellidos){
		this->_apellidos = apellidos;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getApellidos()==apellidos);
		#endif
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rdi
callq 0x20c0
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x8(%rax), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x3820
testq %rdx, %rdx
je 0x3818
movq (%rbx), %rsi
movq (%rax), %rdi
callq 0x2170
testl %eax, %eax
jne 0x3820
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5d47(%rip), %rdi      # 0x956e
leaq 0x5cf3(%rip), %rsi      # 0x9521
leaq 0x5d53(%rip), %rcx      # 0x9588
movl $0xb6, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::setTeoria(float const&)
inline void setTeoria(const float & teoria){
		this->_teoria = teoria;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getTeoria()==teoria);
		#endif
	}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movss (%rsi), %xmm0
movss %xmm0, 0x48(%rdi)
movq (%rdi), %rax
callq *0x20(%rax)
ucomiss (%rbx), %xmm0
jne 0x385c
jp 0x385c
popq %rbx
retq
leaq 0x5d64(%rip), %rdi      # 0x95c7
leaq 0x5cb7(%rip), %rsi      # 0x9521
leaq 0x5d6a(%rip), %rcx      # 0x95db
movl $0xc8, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::setPractica(float const&)
inline void setPractica(const float & practica){
		this->_practica = practica;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getPractica()==practica);
		#endif
	}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movss (%rsi), %xmm0
movss %xmm0, 0x4c(%rdi)
movq (%rdi), %rax
callq *0x28(%rax)
ucomiss (%rbx), %xmm0
jne 0x3898
jp 0x3898
popq %rbx
retq
leaq 0x5d72(%rip), %rdi      # 0x9611
leaq 0x5c7b(%rip), %rsi      # 0x9521
leaq 0x5d7c(%rip), %rcx      # 0x9629
movl $0xda, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/asignatura.cpp
// Function: ed::Asignatura::grabarFichero(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool ed::Asignatura::grabarFichero(std::string const &nombreFichero){
	std::ofstream fichero;

	fichero.open(nombreFichero.c_str()); //Abrimos el fichero con el nombre recibido

	if(!fichero){ //No se ha podido abrir el fichero
		return false;
	}

	else{ //Se ha podido abrir el fichero
		//Escribimos en el fichero el nombre y el código de la asignatura
		fichero << getNombre() << std::endl;
		fichero << getCodigo() << std::endl;

		_arbol.grabar(fichero); //Escribimos el en fichero la lista de estudiantes

		fichero.close(); //Cerramos el fichero

		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x238(%rbp), %r15
movq %r15, %rdi
callq 0x2210
movq (%r14), %rsi
movq %r15, %rdi
movl $0x10, %edx
callq 0x2060
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
movl -0x218(%rbp,%rax), %r15d
testb $0x5, %r15b
jne 0x3d80
movq (%rbx), %rax
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x238(%rbp), %rdi
callq 0x2190
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d21
callq 0x2140
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
leaq -0x238(%rbp), %rdi
movl %eax, %esi
callq 0x2220
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x30, %rbx
leaq -0x238(%rbp), %rsi
movq %rbx, %rdi
callq 0x33e4
leaq -0x238(%rbp), %rdi
callq 0x21c0
testb $0x5, %r15b
sete %bl
leaq -0x238(%rbp), %rdi
callq 0x21d0
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3dbc
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3dbf
callq 0x2140
jmp 0x3dbf
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x362e
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/funcionesAuxiliares.cpp
// Function: ed::comprobarAsignaturaVacia(ed::Asignatura const&)
void ed::comprobarAsignaturaVacia(ed::Asignatura const &asignatura){
	std::cout << std::endl << IPURPLE "La asignatura de nombre < " << asignatura.getNombre() << " > ";

	if (asignatura.estaVacia()){ //La asignatura está vacía
		std::cout << "está vacía" << RESET;
	}

	else{ //La asignatura no está vacía
		std::cout << "no está vacía" << RESET;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8e02(%rip), %r14      # 0xcfd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rax, %r14
leaq 0x57c1(%rip), %rsi      # 0x99c0
movl $0x21, %edx
movq %rax, %rdi
callq 0x2190
movq (%rbx), %rax
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2190
leaq 0x57b0(%rip), %rsi      # 0x99e2
movl $0x3, %edx
movq %rax, %rdi
callq 0x2190
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4251
callq 0x2140
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8d6f(%rip), %rdi      # 0xcfd0
testb %al, %al
je 0x4273
leaq 0x55dd(%rip), %rsi      # 0x9849
movl $0xc, %edx
jmp 0x427f
leaq 0x576c(%rip), %rsi      # 0x99e6
movl $0xf, %edx
callq 0x2190
movq 0x8d45(%rip), %rdi      # 0xcfd0
leaq 0x5b1d(%rip), %rsi      # 0x9daf
movl $0x4, %edx
callq 0x2190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42bc
callq 0x2140
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/funcionesAuxiliares.cpp
// Function: ed::borrarAsignatura(ed::Asignatura&)
void ed::borrarAsignatura(ed::Asignatura &asignatura){
	asignatura.setCodigo(0); //Borramos el código de la asignatura
	asignatura.setNombre(""); //Borramos el nombre de la asignatura

	//Borramos la lista de estudiantes
	while(!asignatura.estaVacia()){	
		asignatura.borrarEstudiante(0);
	}

	std::cout << std::endl << CYAN << "Asignatura borrada correctamente" << RESET << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
xorl %esi, %esi
callq *0x38(%rax)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x52f8(%rip), %rdx      # 0x9821
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x38b8
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4552
callq 0x2140
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
jne 0x45c3
leaq 0x30(%rbx), %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testl %eax, %eax
js 0x4662
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testl %eax, %eax
js 0x45b6
movq %r14, %rdi
xorl %esi, %esi
callq 0x2dd2
movq %r14, %rdi
movq %rax, %rsi
callq 0x311e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, %r15d
jne 0x4681
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x4563
movq 0x8a06(%rip), %rbx      # 0xcfd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rax, %rbx
leaq 0x5458(%rip), %rsi      # 0x9a53
movl $0x7, %edx
movq %rax, %rdi
callq 0x2190
leaq 0x561e(%rip), %rsi      # 0x9c2d
movl $0x20, %edx
movq %rbx, %rdi
callq 0x2190
leaq 0x578c(%rip), %rsi      # 0x9daf
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x58d6(%rip), %rdi      # 0x9f3f
leaq 0x50d3(%rip), %rsi      # 0x9743
leaq 0x58e4(%rip), %rcx      # 0x9f5b
movl $0x1ad, %edx            # imm = 0x1AD
callq 0x20f0
leaq 0x59c7(%rip), %rdi      # 0xa04f
leaq 0x50b4(%rip), %rsi      # 0x9743
leaq 0x58c5(%rip), %rcx      # 0x9f5b
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x20f0
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x46b1
callq 0x2140
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::borrarEstudiante(ed::Estudiante const&)
inline bool borrarEstudiante(ed::Estudiante const &estudiante){
		//Precondición
		#ifndef NDEBUG
			assert(existeEstudiante(estudiante.getNombre(),estudiante.getApellidos()));
		#endif

		int old=getNumeroEstudiantes();

		if(!existeEstudiante(estudiante)){ //No existe el estudiante
			return false;
		}

		else{ //Sí existe el estudiante
			_arbol.remove(estudiante); //Borramos el estudiante

			//Postcondición
			#ifndef NDEBUG
				assert(!existeEstudiante(estudiante.getNombre(),estudiante.getApellidos()) and old==getNumeroEstudiantes()+1);
			#endif

			return true;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq *0x20(%rcx)
testb %al, %al
je 0x7229
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r15d
leaq 0x30(%rbx), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2cfc
movl %eax, %r12d
testb %al, %al
je 0x7217
movq %r13, %rdi
movq %r14, %rsi
callq 0x311e
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq *0x20(%rcx)
testb %al, %al
jne 0x7248
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, %r15d
jne 0x7248
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d56(%rip), %rdi      # 0x9f86
leaq 0x250c(%rip), %rsi      # 0x9743
leaq 0x2d8b(%rip), %rcx      # 0x9fc9
movl $0x18a, %edx            # imm = 0x18A
callq 0x20f0
leaq 0x2db8(%rip), %rdi      # 0xa007
leaq 0x24ed(%rip), %rsi      # 0x9743
leaq 0x2d6c(%rip), %rcx      # 0x9fc9
movl $0x198, %edx            # imm = 0x198
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::Asignatura(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Asignatura(int codigo=0,std::string const &nombre=""){
		this->setCodigo(codigo);
		this->setNombre(nombre);

		/*
			El constructor de NodoEnlazadoArbolBinarioEstudiante 
    			asigna valores nulos
		*/
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r12
leaq 0x54aa(%rip), %rax      # 0xcd30
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
leaq 0x20(%rdi), %r13
movq %r13, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
leaq 0x30(%rdi), %r15
leaq 0x53a4(%rip), %rax      # 0xcc50
movq %rax, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movl %esi, 0x8(%rdi)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x20c0
movq (%r12), %rax
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x7917
testq %rdx, %rdx
je 0x78f6
movq (%rbx), %rsi
movq -0x48(%rbp), %rdi
callq 0x2170
testl %eax, %eax
jne 0x7917
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7908
callq 0x2140
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bef(%rip), %rdi      # 0x950d
leaq 0x1e1e(%rip), %rsi      # 0x9743
leaq 0x2944(%rip), %rcx      # 0xa270
movl $0xef, %edx
callq 0x20f0
movq %rax, %rbx
leaq 0x5310(%rip), %rax      # 0xcc50
movq %rax, (%r15)
movq %r15, %rdi
callq 0x2c5c
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x7958
callq 0x2140
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x362e
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::existeEstudiante(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool existeEstudiante(std::string const &nombre, std::string const &apellidos){
		// Se crea un estudiante auxiliar con el nombre y los apellidos
		ed::Estudiante estudiante(nombre,apellidos,0,0);
   
		// Se llama a la función exists de _arbol
		return this->_arbol.exists(estudiante); 
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x8094
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x8094
leaq -0xb0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3ddc
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x7a96
callq 0x2140
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x7aa4
callq 0x2140
addq $0x30, %rbx
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0x2cfc
movl %eax, %ebx
leaq -0xb0(%rbp), %rdi
callq 0x3518
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x3518
jmp 0x7b14
movq %rax, %rdi
callq 0x362e
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x7b06
callq 0x2140
jmp 0x7b06
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x7b14
callq 0x2140
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::getEstudiante(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline ed::Estudiante const & getEstudiante(std::string const &nombre, std::string const &apellidos){
		//Precondición
		#ifndef NDEBUG
			assert(existeEstudiante(nombre,apellidos));
		#endif

		ed::Estudiante estudiante(nombre,apellidos,0,0); //Creamos un estudiante con los datos recibidos

		return _arbol.getEstudiante(estudiante); //Devolvemos el estudiante a buscar
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x7be7
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x8094
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x8094
leaq -0xb0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3ddc
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x7ba4
callq 0x2140
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x7bb2
callq 0x2140
addq $0x30, %rbx
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0x2d5a
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x3518
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26bf(%rip), %rdi      # 0xa2ad
leaq 0x1b4e(%rip), %rsi      # 0x9743
leaq 0x256e(%rip), %rcx      # 0xa16a
movl $0x9a, %edx
callq 0x20f0
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x3518
jmp 0x7c43
movq %rax, %rdi
callq 0x362e
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x7c35
callq 0x2140
jmp 0x7c35
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x7c43
callq 0x2140
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::getEstudiante(int)
inline ed::Estudiante const & getEstudiante(int indice){
		//Precondición
		#ifndef NDEBUG
			assert(indice<=getNumeroEstudiantes());
		#endif

		return _arbol.getEstudiante(indice); //Devolvemos el estudiante con el indice recibido
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x18(%rax)
cmpl %ebx, %eax
jl 0x7c74
addq $0x30, %r14
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2dd2
leaq 0x2555(%rip), %rdi      # 0xa1d0
leaq 0x1ac1(%rip), %rsi      # 0x9743
leaq 0x2566(%rip), %rcx      # 0xa1ef
movl $0xc5, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::setCodigo(int)
inline void setCodigo(int codigo){
		this->_codigo = codigo;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getCodigo()==codigo);
		#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %esi, 0x8(%rdi)
movq (%rdi), %rax
callq *(%rax)
cmpl %ebx, %eax
jne 0x7caf
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x257a(%rip), %rdi      # 0xa230
leaq 0x1a86(%rip), %rsi      # 0x9743
leaq 0x2580(%rip), %rcx      # 0xa244
movl $0xdd, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::setNombre(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline  void setNombre(std::string const & nombre){
		this->_nombre = nombre;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getNombre()==nombre);
		#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdi
callq 0x20c0
movq (%r14), %rax
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x8(%rax)
movq 0x8(%r15), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x7d36
testq %rdx, %rdx
je 0x7d19
movq (%rbx), %rsi
movq -0x38(%rbp), %rdi
callq 0x2170
testl %eax, %eax
jne 0x7d36
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d2b
callq 0x2140
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17d0(%rip), %rdi      # 0x950d
leaq 0x19ff(%rip), %rsi      # 0x9743
leaq 0x2525(%rip), %rcx      # 0xa270
movl $0xef, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::insertarEstudiante(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, float, float)
inline bool insertarEstudiante(std::string const &nombre, std::string const &apellidos,float teoria, float practica){
		//Precondición
		#ifndef NDEBUG
			assert(!existeEstudiante(nombre,apellidos));
		#endif

		int old=getNumeroEstudiantes();
		ed::Estudiante estudiante(nombre,apellidos,teoria,practica); //Creamos un estudiante con los datos recibidos

		if(existeEstudiante(estudiante)){ //Ya existe el estudiante
			return false;
		}

		else{ //No existe el estudiante
			_arbol.insert(estudiante); //Insertamos el estudiante

			//Postcondición
			#ifndef NDEBUG
				assert(existeEstudiante(nombre,apellidos) and old==getNumeroEstudiantes()-1);
			#endif

			return true;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movss %xmm1, -0x34(%rbp)
movss %xmm0, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x7e7a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, -0x2c(%rbp)
leaq -0x68(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x8094
leaq -0x48(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x8094
leaq -0xc8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdx
movss -0x30(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
callq 0x3ddc
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x7dfb
callq 0x2140
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x7e09
callq 0x2140
leaq 0x30(%rbx), %r14
leaq -0xc8(%rbp), %rsi
movq %r14, %rdi
callq 0x2cfc
movl %eax, %r13d
testb %al, %al
jne 0x7e55
leaq -0xc8(%rbp), %rsi
movq %r14, %rdi
callq 0x2f3c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x7e99
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
decl %eax
cmpl %eax, -0x2c(%rbp)
jne 0x7e99
xorb $0x1, %r13b
leaq -0xc8(%rbp), %rdi
callq 0x3518
movl %r13d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x242b(%rip), %rdi      # 0xa2ac
leaq 0x18bb(%rip), %rsi      # 0x9743
leaq 0x2441(%rip), %rcx      # 0xa2d0
movl $0x11d, %edx            # imm = 0x11D
callq 0x20f0
leaq 0x2498(%rip), %rdi      # 0xa338
leaq 0x189c(%rip), %rsi      # 0x9743
leaq 0x2422(%rip), %rcx      # 0xa2d0
movl $0x12c, %edx            # imm = 0x12C
callq 0x20f0
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x7ece
callq 0x2140
jmp 0x7ece
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x7eed
callq 0x2140
jmp 0x7eed
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x3518
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x362e
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::borrarEstudiante(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool borrarEstudiante(std::string const &nombre, std::string const &apellidos){
		//Precondición
		#ifndef NDEBUG
			assert(existeEstudiante(nombre,apellidos));
		#endif

		int old=getNumeroEstudiantes();
		ed::Estudiante estudiante(nombre,apellidos,0,0); //Creamos un estudiante con los datos recibidos

		if(!existeEstudiante(estudiante)){ //No existe el estudiante
			return false;
		}

		else{ //Si existe el estudiante
			_arbol.remove(estudiante); //Borramos el estudiante

			//Postcondición
			#ifndef NDEBUG
				assert(!existeEstudiante(nombre,apellidos) and old==getNumeroEstudiantes()+1);
			#endif

			return true;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x8010
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x8094
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x8094
leaq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3ddc
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x7f95
callq 0x2140
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x7fa3
callq 0x2140
leaq 0x30(%rbx), %r14
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x2cfc
movl %eax, %r13d
testb %al, %al
je 0x7fef
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x311e
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x20(%rax)
testb %al, %al
jne 0x802f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, -0x2c(%rbp)
jne 0x802f
leaq -0xc0(%rbp), %rdi
callq 0x3518
movl %r13d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2296(%rip), %rdi      # 0xa2ad
leaq 0x1725(%rip), %rsi      # 0x9743
leaq 0x2358(%rip), %rcx      # 0xa37d
movl $0x166, %edx            # imm = 0x166
callq 0x20f0
leaq 0x239f(%rip), %rdi      # 0xa3d5
leaq 0x1706(%rip), %rsi      # 0x9743
leaq 0x2339(%rip), %rcx      # 0xa37d
movl $0x175, %edx            # imm = 0x175
callq 0x20f0
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x8064
callq 0x2140
jmp 0x8064
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x8083
callq 0x2140
jmp 0x8083
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3518
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x362e
nop
// File: /workspace/github_cpp_makefile_star2_O1/iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::Graph(Graph const&)
Graph::Graph(const Graph &graph) {
    nodeIndex = graph.nodeIndex;
    zeroDegreeNodes = graph.zeroDegreeNodes;
    nextUnusedId = graph.nextUnusedId;
    mapping = graph.mapping;
    edgeBuffer = new vector<uint32_t>(*(graph.edgeBuffer));
    if (graph.mapping) {
        idToPos = new unordered_map<uint32_t, uint32_t>(*(graph.idToPos));
        posToId = new vector<uint32_t>(*(graph.posToId));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
callq 0xbde6
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0xbee6
movl 0x38(%r15), %eax
movl %eax, 0x38(%rbx)
movb 0x3c(%r15), %al
movb %al, 0x3c(%rbx)
movl $0x18, %edi
callq 0x21e0
movq %rax, %r12
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0xbfb4
movq %r12, 0x18(%rbx)
cmpb $0x1, 0x3c(%r15)
jne 0x2821
movl $0x38, %edi
callq 0x21e0
movq %rax, %r12
movq 0x40(%r15), %rsi
xorl %eax, %eax
movq %rax, (%r12)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%r12)
movq %rax, 0x10(%r12)
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%r12)
movups 0x20(%rsi), %xmm0
movups %xmm0, 0x20(%r12)
movq %rax, 0x30(%r12)
movq %rsp, %rdx
movq %r12, (%rdx)
movq %r12, %rdi
callq 0xcd1e
movq %r12, 0x40(%rbx)
movl $0x18, %edi
callq 0x21e0
movq %rax, %r12
movq 0x48(%r15), %rsi
movq %rax, %rdi
callq 0xbfb4
movq %r12, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2831
jmp 0x2831
movq %rax, %r15
movq %r12, %rdi
callq 0x21a0
jmp 0x2841
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x284e
callq 0x21a0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x285b
callq 0x21a0
movq %r15, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::operator=(Graph const&)
Graph& Graph::operator=(const Graph &graph) {
    if (this != &graph) {
        nodeIndex = graph.nodeIndex;
        zeroDegreeNodes = graph.zeroDegreeNodes;
        nextUnusedId = graph.nextUnusedId;
        mapping = graph.mapping;
        edgeBuffer = new vector<uint32_t>(*(graph.edgeBuffer));
        if (graph.mapping) {
            idToPos = new unordered_map<uint32_t, uint32_t>(*(graph.idToPos));
            posToId = new vector<uint32_t>(*(graph.posToId));
        }
    }
    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x292b
movq %rsi, %r14
movq %rbx, %rdi
callq 0xbde6
leaq 0x20(%r14), %rsi
leaq 0x20(%rbx), %rdi
callq 0xbee6
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
movb 0x3c(%r14), %al
movb %al, 0x3c(%rbx)
movl $0x18, %edi
callq 0x21e0
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0xbfb4
movq %r15, 0x18(%rbx)
cmpb $0x1, 0x3c(%r14)
jne 0x292b
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq 0x40(%r14), %rsi
xorl %eax, %eax
movq %rax, (%r15)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%r15)
movq %rax, 0x10(%r15)
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%r15)
movups 0x20(%rsi), %xmm0
movups %xmm0, 0x20(%r15)
movq %rax, 0x30(%r15)
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movq %r15, %rdi
callq 0xcd1e
movq %r15, 0x40(%rbx)
movl $0x18, %edi
callq 0x21e0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq %rax, %rdi
callq 0xbfb4
movq %r15, 0x48(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x293c
jmp 0x293c
movq %rax, %rbx
movq %r15, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::~Graph()
Graph::~Graph() {
    delete edgeBuffer;
    if (mapping) {
        delete idToPos;
        delete posToId;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x2975
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296d
callq 0x21a0
movq %r14, %rdi
callq 0x21a0
cmpb $0x1, 0x3c(%rbx)
jne 0x29b2
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x2994
movq %r14, %rdi
callq 0xcebc
movq %r14, %rdi
callq 0x21a0
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x29b2
movq (%r14), %rdi
testq %rdi, %rdi
je 0x29aa
callq 0x21a0
movq %r14, %rdi
callq 0x21a0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x29c0
callq 0x21a0
movq (%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x29d4
popq %rbx
popq %r14
jmp 0x21a0
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getMaxNodeDegree(unsigned int&, unsigned int&, unsigned int const&) const
void Graph::getMaxNodeDegree(uint32_t &node, uint32_t &maxDegree, const uint32_t &bound) const {
    node = NONE;
    maxDegree = 0;
    for (uint32_t i = 0 ; i < nodeIndex.size() ; i++) {
        if (!nodeIndex[i].removed && nodeIndex[i].edges > maxDegree) {
            node = (!mapping ? i : posToId->at(i));
            maxDegree = nodeIndex[i].edges;
            if (bound != NONE && maxDegree >= bound) {
                return;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
movl $0x0, (%rdx)
movq (%rdi), %r9
movq 0x8(%rdi), %rax
subq %r9, %rax
je 0x2a9b
sarq $0x2, %rax
movabsq $-0x5555555555555555, %r10 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r10
movb 0x3c(%rdi), %r11b
movq 0x48(%rdi), %rdi
xorl %eax, %eax
leaq (%rax,%rax,2), %r8
cmpb $0x0, 0x8(%r9,%r8,4)
jne 0x2a94
leaq (%r9,%r8,4), %rbx
movl 0x4(%rbx), %r8d
cmpl (%rdx), %r8d
jbe 0x2a94
movl %eax, %r8d
testb $0x1, %r11b
je 0x2a71
movq (%rdi), %r14
movq 0x8(%rdi), %r8
subq %r14, %r8
sarq $0x2, %r8
cmpq %rax, %r8
jbe 0x2aa0
movl (%r14,%rax,4), %r8d
movl %r8d, (%rsi)
movl 0x4(%rbx), %r8d
movl %r8d, (%rdx)
movl (%rcx), %ebx
cmpl $-0x1, %ebx
sete %bpl
cmpl %ebx, %r8d
setb %r8b
orb %bpl, %r8b
cmpb $0x1, %r8b
jne 0x2a9b
incl %eax
cmpq %rax, %r10
ja 0x2a38
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x17d37(%rip), %rdi     # 0x1a7de
movq %rax, %rsi
movq %r8, %rdx
xorl %eax, %eax
callq 0x22a0