LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
callq 0x2d06
testb %al, %al
je 0x2dc3
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 0x2dbe
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a28
xorb $0x1, %al
movzbl %al, %eax
movq 0x10(%r14,%rax,8), %r14
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x2d74
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6515(%rip), %rdi      # 0x92df
leaq 0x6364(%rip), %rsi      # 0x9135
leaq 0x6384(%rip), %rcx      # 0x915c
movl $0x5f, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e3c
movq %r15, %r14
movq %r15, %rdi
callq 0x2cba
cmpl %ebx, %eax
jl 0x2e3c
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x2e1d
movq %r15, %rdi
callq 0x2cba
cmpl %ebx, %eax
je 0x2e2e
jg 0x2dec
notl %eax
jmp 0x2e26
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ebx, %ebx
je 0x2e2e
addl %eax, %ebx
movq 0x18(%r14), %r15
jmp 0x2dec
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x10(%rax)
leaq 0x637d(%rip), %rdi      # 0x91c0
leaq 0x62eb(%rip), %rsi      # 0x9135
leaq 0x638f(%rip), %rcx      # 0x91e0
movl $0x74, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e7a
movq %rax, %rdi
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x2e60
movq (%rdi), %rax
popq %rcx
jmpq *0x10(%rax)
leaq 0x63b0(%rip), %rdi      # 0x9231
leaq 0x62ad(%rip), %rsi      # 0x9135
leaq 0x63ad(%rip), %rcx      # 0x923c
movl $0x93, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d06
testb %al, %al
je 0x2f0e
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 0x2ed3
movq %rbx, %rsi
callq *0x18(%rcx)
jmp 0x2ef7
callq *0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a28
testb %al, %al
je 0x2eeb
movq 0x10(%r14), %rdi
jmp 0x2eef
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x2e9a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d06
testb %al, %al
je 0x2f2d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x63ca(%rip), %rdi      # 0x92df
leaq 0x6219(%rip), %rsi      # 0x9135
leaq 0x6368(%rip), %rcx      # 0x928b
movl $0xa2, %edx
callq 0x20f0
leaq 0x63ab(%rip), %rdi      # 0x92df
leaq 0x61fa(%rip), %rsi      # 0x9135
leaq 0x6349(%rip), %rcx      # 0x928b
movl $0xb3, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9c7a(%rip), %r14      # 0xcfd0
cmpq $0x0, 0x8(%rbx)
je 0x33b4
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x336b
callq 0x3348
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 0x3356
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5e76(%rip), %rdi      # 0x9231
leaq 0x5d73(%rip), %rsi      # 0x9135
leaq 0x5fc6(%rip), %rcx      # 0x938f
movl $0x166, %edx            # imm = 0x166
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x341b
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 0x340a
movq %rbx, %rsi
callq 0x33d4
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x33de
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5e0f(%rip), %rdi      # 0x9231
leaq 0x5d0c(%rip), %rsi      # 0x9135
leaq 0x5f96(%rip), %rcx      # 0x93c6
movl $0x178, %edx            # imm = 0x178
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x978d(%rip), %rax      # 0xcca8
movq %rax, (%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x62f3(%rip), %rdx      # 0x9821
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x38a8
movq (%rbx), %rax
movq %rsp, %rsi
movq %rbx, %rdi
callq *0x30(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3553
callq 0x2140
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x62c1(%rip), %rdx      # 0x9821
movq %rdx, %rsi
callq 0x38a8
movq (%rbx), %rax
movq %rsp, %rsi
movq %rbx, %rdi
callq *0x38(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3582
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 0x35b8
callq 0x2140
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x35ca
callq 0x2140
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x35ef
jmp 0x35ef
jmp 0x35dc
jmp 0x35ef
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x35f2
callq 0x2140
jmp 0x35f2
movq %rax, %r14
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x3604
callq 0x2140
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x3616
callq 0x2140
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x36ba
movq %rbx, %rsi
callq 0x28f2
jmp 0x36d6
movl $0x50, %edi
callq 0x2160
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x343a
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 0x36f4
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5da8(%rip), %rdi      # 0x94a3
leaq 0x5d09(%rip), %rsi      # 0x940b
leaq 0x5daf(%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_O3/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 0x37ae
testq %rdx, %rdx
je 0x37a6
movq (%rbx), %rsi
movq (%rax), %rdi
callq 0x2170
testl %eax, %eax
jne 0x37ae
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5d58(%rip), %rdi      # 0x950d
leaq 0x5d65(%rip), %rsi      # 0x9521
leaq 0x5d6f(%rip), %rcx      # 0x9532
movl $0xa4, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3810
testq %rdx, %rdx
je 0x3808
movq (%rbx), %rsi
movq (%rax), %rdi
callq 0x2170
testl %eax, %eax
jne 0x3810
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5d57(%rip), %rdi      # 0x956e
leaq 0x5d03(%rip), %rsi      # 0x9521
leaq 0x5d63(%rip), %rcx      # 0x9588
movl $0xb6, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x384c
jp 0x384c
popq %rbx
retq
leaq 0x5d74(%rip), %rdi      # 0x95c7
leaq 0x5cc7(%rip), %rsi      # 0x9521
leaq 0x5d7a(%rip), %rcx      # 0x95db
movl $0xc8, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3888
jp 0x3888
popq %rbx
retq
leaq 0x5d82(%rip), %rdi      # 0x9611
leaq 0x5c8b(%rip), %rsi      # 0x9521
leaq 0x5d8c(%rip), %rcx      # 0x9629
movl $0xda, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3d62
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 0x3d03
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 0x33d4
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 0x3d9e
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3da1
callq 0x2140
jmp 0x3da1
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x361e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8e22(%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 0x57e1(%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 0x57d0(%rip), %rsi      # 0x99e2
movl $0x3, %edx
movq %rax, %rdi
callq 0x2190
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4231
callq 0x2140
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8d8f(%rip), %rdi      # 0xcfd0
testb %al, %al
je 0x4253
leaq 0x55fd(%rip), %rsi      # 0x9849
movl $0xc, %edx
jmp 0x425f
leaq 0x578c(%rip), %rsi      # 0x99e6
movl $0xf, %edx
callq 0x2190
movq 0x8d65(%rip), %rdi      # 0xcfd0
leaq 0x5b3d(%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 0x429c
callq 0x2140
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5318(%rip), %rdx      # 0x9821
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x38a8
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4532
callq 0x2140
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
jne 0x45a3
leaq 0x30(%rbx), %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testl %eax, %eax
js 0x4642
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 0x4596
movq %r14, %rdi
xorl %esi, %esi
callq 0x2de2
movq %r14, %rdi
movq %rax, %rsi
callq 0x311c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, %r15d
jne 0x4661
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x4543
movq 0x8a26(%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 0x5478(%rip), %rsi      # 0x9a53
movl $0x7, %edx
movq %rax, %rdi
callq 0x2190
leaq 0x563e(%rip), %rsi      # 0x9c2d
movl $0x20, %edx
movq %rbx, %rdi
callq 0x2190
leaq 0x57ac(%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 0x58f6(%rip), %rdi      # 0x9f3f
leaq 0x50f3(%rip), %rsi      # 0x9743
leaq 0x5904(%rip), %rcx      # 0x9f5b
movl $0x1ad, %edx            # imm = 0x1AD
callq 0x20f0
leaq 0x59e7(%rip), %rdi      # 0xa04f
leaq 0x50d4(%rip), %rsi      # 0x9743
leaq 0x58e5(%rip), %rcx      # 0x9f5b
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x20f0
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4691
callq 0x2140
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x71fb
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r15d
leaq 0x30(%rbx), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2d06
movl %eax, %r12d
testb %al, %al
je 0x71e9
movq %r13, %rdi
movq %r14, %rsi
callq 0x311c
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 0x721a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, %r15d
jne 0x721a
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d84(%rip), %rdi      # 0x9f86
leaq 0x253a(%rip), %rsi      # 0x9743
leaq 0x2db9(%rip), %rcx      # 0x9fc9
movl $0x18a, %edx            # imm = 0x18A
callq 0x20f0
leaq 0x2de6(%rip), %rdi      # 0xa007
leaq 0x251b(%rip), %rsi      # 0x9743
leaq 0x2d9a(%rip), %rcx      # 0x9fc9
movl $0x198, %edx            # imm = 0x198
callq 0x20f0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x54ac(%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 0x53a6(%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
movq -0x48(%rbp), %r14
testq %rdx, %rdx
je 0x78f7
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2170
testl %eax, %eax
jne 0x7917
leaq -0x38(%rbp), %rax
cmpq %rax, %r14
je 0x7908
movq %r14, %rdi
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 0x361e
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8096
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x8096
leaq -0xb0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3dbe
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 0x2d06
movl %eax, %ebx
leaq -0xb0(%rbp), %rdi
callq 0x3508
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 0x3508
jmp 0x7b14
movq %rax, %rdi
callq 0x361e
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_O3/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 0x8096
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x8096
leaq -0xb0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3dbe
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 0x2d6a
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x3508
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 0x3508
jmp 0x7c43
movq %rax, %rdi
callq 0x361e
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_O3/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 0x2de2
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_O3/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 0x7d38
movq -0x38(%rbp), %r14
testq %rdx, %rdx
je 0x7d1c
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2170
testl %eax, %eax
jne 0x7d38
leaq -0x28(%rbp), %rax
cmpq %rax, %r14
je 0x7d2d
movq %r14, %rdi
callq 0x2140
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17ce(%rip), %rdi      # 0x950d
leaq 0x19fd(%rip), %rsi      # 0x9743
leaq 0x2523(%rip), %rcx      # 0xa270
movl $0xef, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7e7c
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 0x8096
leaq -0x48(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x8096
leaq -0xc8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdx
movss -0x30(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
callq 0x3dbe
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x7dfd
callq 0x2140
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x7e0b
callq 0x2140
leaq 0x30(%rbx), %r14
leaq -0xc8(%rbp), %rsi
movq %r14, %rdi
callq 0x2d06
movl %eax, %r13d
testb %al, %al
jne 0x7e57
leaq -0xc8(%rbp), %rsi
movq %r14, %rdi
callq 0x2f4c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x7e9b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
decl %eax
cmpl %eax, -0x2c(%rbp)
jne 0x7e9b
xorb $0x1, %r13b
leaq -0xc8(%rbp), %rdi
callq 0x3508
movl %r13d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2429(%rip), %rdi      # 0xa2ac
leaq 0x18b9(%rip), %rsi      # 0x9743
leaq 0x243f(%rip), %rcx      # 0xa2d0
movl $0x11d, %edx            # imm = 0x11D
callq 0x20f0
leaq 0x2496(%rip), %rdi      # 0xa338
leaq 0x189a(%rip), %rsi      # 0x9743
leaq 0x2420(%rip), %rcx      # 0xa2d0
movl $0x12c, %edx            # imm = 0x12C
callq 0x20f0
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x7ed0
callq 0x2140
jmp 0x7ed0
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x7eef
callq 0x2140
jmp 0x7eef
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x3508
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x361e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8012
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 0x8096
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x8096
leaq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3dbe
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x7f97
callq 0x2140
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x7fa5
callq 0x2140
leaq 0x30(%rbx), %r14
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x2d06
movl %eax, %r13d
testb %al, %al
je 0x7ff1
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x311c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x20(%rax)
testb %al, %al
jne 0x8031
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, -0x2c(%rbp)
jne 0x8031
leaq -0xc0(%rbp), %rdi
callq 0x3508
movl %r13d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2294(%rip), %rdi      # 0xa2ad
leaq 0x1723(%rip), %rsi      # 0x9743
leaq 0x2356(%rip), %rcx      # 0xa37d
movl $0x166, %edx            # imm = 0x166
callq 0x20f0
leaq 0x239d(%rip), %rdi      # 0xa3d5
leaq 0x1704(%rip), %rsi      # 0x9743
leaq 0x2337(%rip), %rcx      # 0xa37d
movl $0x175, %edx            # imm = 0x175
callq 0x20f0
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x8066
callq 0x2140
jmp 0x8066
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x8085
callq 0x2140
jmp 0x8085
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3508
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x361e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb6ec
leaq 0x20(%r14), %rsi
leaq 0x20(%rbx), %rdi
callq 0xb7ee
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 0xb8ca
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 0xc682
movq %r15, 0x40(%rbx)
movl $0x18, %edi
callq 0x21e0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq %rax, %rdi
callq 0xb8ca
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_O3/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 0x296d
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 0x298c
movq %r14, %rdi
callq 0xc81c
movq %r14, %rdi
callq 0x21a0
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x29aa
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_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
movl $0x0, (%rdx)
movq (%rdi), %r9
movq 0x8(%rdi), %rax
subq %r9, %rax
je 0x2aa6
sarq $0x2, %rax
movabsq $-0x5555555555555555, %r10 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r10
movb 0x3c(%rdi), %r11b
movq 0x48(%rdi), %rdi
xorl %r8d, %r8d
xorl %eax, %eax
xorl %ebx, %ebx
leaq (%rax,%rax,2), %r14
cmpb $0x0, 0x8(%r9,%r14,4)
jne 0x2a5a
leaq (%r9,%r14,4), %r14
cmpl %r8d, 0x4(%r14)
ja 0x2a66
incl %ebx
movq %rbx, %rax
cmpq %rbx, %r10
ja 0x2a44
jmp 0x2aa6
movl %ebx, %r8d
testb $0x1, %r11b
je 0x2a86
movq (%rdi), %r15
movq 0x8(%rdi), %r8
subq %r15, %r8
sarq $0x2, %r8
cmpq %rax, %r8
jbe 0x2ab1
movl (%r15,%rax,4), %r8d
movl %r8d, (%rsi)
movl 0x4(%r14), %r8d
movl %r8d, (%rdx)
movl (%rcx), %eax
cmpl $-0x1, %eax
sete %bpl
cmpl %eax, %r8d
setb %al
orb %bpl, %al
cmpb $0x1, %al
je 0x2a5a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16d26(%rip), %rdi     # 0x197de
movq %rax, %rsi
movq %r8, %rdx
xorl %eax, %eax
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getMinDegree(unsigned int&) const
void Graph::getMinDegree(uint32_t &minDegree) const {
    minDegree = NONE;
    for (uint32_t i = 0 ; i < nodeIndex.size() ; i++) {
        if (!nodeIndex[i].removed && nodeIndex[i].edges && nodeIndex[i].edges < minDegree) {
            minDegree = nodeIndex[i].edges;
            if (minDegree < 3) {
                return;
            }
        }
    }
}

// Assembly:
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
subq %rax, %rdx
je 0x2b38
sarq $0x2, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x1, %edx
xorl %r8d, %r8d
leaq (%r8,%r8,2), %r8
cmpb $0x0, 0x8(%rax,%r8,4)
jne 0x2b2e
leaq (%rax,%r8,4), %r8
movl 0x4(%r8), %r8d
testl %r8d, %r8d
setne %r9b
cmpl %edi, %r8d
setb %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x2b2e
movl %r8d, (%rsi)
movl %r8d, %edi
cmpl $0x3, %r8d
jb 0x2b38
movl %edx, %r8d
incl %edx
cmpq %r8, %rcx
ja 0x2af7
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getTotalEdges() const
uint32_t Graph::getTotalEdges() const {
    uint32_t count = 0;
    for (uint32_t pos = 0 ; pos < nodeIndex.size() ; pos++) {
        if (!nodeIndex[pos].removed) {
            count += nodeIndex[pos].edges;
        }
    }
    return count;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
je 0x2b79
sarq $0x2, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
addq $0x8, %rcx
xorl %eax, %eax
movl $0x1, %esi
cmpb $0x0, (%rcx)
jne 0x2b6b
addl -0x4(%rcx), %eax
movl %esi, %edi
addq $0xc, %rcx
incl %esi
cmpq %rdi, %rdx
ja 0x2b63
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::replaceNeighbor(unsigned int const&, unsigned int const&, unsigned int const&)
void Graph::replaceNeighbor(const uint32_t &node, const uint32_t &oldNeighbor, const uint32_t &newNeighbor) {
    uint32_t offset;
    offset = findEdgeOffset(node, oldNeighbor);
    assert(offset != NONE);
    uint32_t pos = (!mapping ? node : idToPos->at(node));
    uint32_t endOffset = (pos == nodeIndex.size()-1 ? edgeBuffer->size() : nodeIndex[pos+1].offset);
    auto it = edgeBuffer->begin();
    move(it + offset + 1, it + endOffset, it + offset);
    (*edgeBuffer)[endOffset-1] = newNeighbor;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xbf3a
cmpl $-0x1, %eax
je 0x3c53
movl %eax, %ebp
cmpb $0x1, 0x3c(%r14)
jne 0x3bcd
movq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0xd37a
testq %rax, %rax
je 0x3c72
movq %rax, %r15
addq $0xc, %r15
movl (%r15), %eax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rsi
decq %rsi
cmpq %rax, %rsi
jne 0x3c08
movq 0x18(%r14), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %r15
subq %rax, %r15
shrq $0x2, %r15
jmp 0x3c19
incl %eax
leaq (%rax,%rax,2), %rax
movl (%rcx,%rax,4), %r15d
movq 0x18(%r14), %rax
movq (%rax), %rax
movl %ebp, %ecx
leaq (%rax,%rcx,4), %rsi
addq $0x4, %rsi
movl %r15d, %edx
leaq (%rax,%rdx,4), %rdx
subq %rsi, %rdx
je 0x3c38
leaq (%rax,%rcx,4), %rdi
callq 0x22f0
movl (%rbx), %eax
movq 0x18(%r14), %rcx
decl %r15d
movq (%rcx), %rcx
movl %eax, (%rcx,%r15,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x154d3(%rip), %rdi     # 0x1912d
leaq 0x153e1(%rip), %rsi     # 0x19042
leaq 0x154d4(%rip), %rcx     # 0x1913c
movl $0x139, %edx            # imm = 0x139
callq 0x2110
leaq 0x15b57(%rip), %rdi     # 0x197d0
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getNodeWithOneUncommonNeighbor(std::vector<unsigned int, std::allocator<unsigned int>> const&, unsigned int&) const
uint32_t Graph::getNodeWithOneUncommonNeighbor(const vector<uint32_t> &neighbors, uint32_t &uncommonNeighbor) const {
    uncommonNeighbor = NONE;
    for (uint32_t pos = 0 ; pos < nodeIndex.size() ; pos++) {
        if (!nodeIndex[pos].removed && nodeIndex[pos].edges == 3 || nodeIndex[pos].edges == 4) { // Optimization for 3-4 structures reduction
            uint32_t node = (!mapping ? pos : posToId->at(pos));
            vector<uint32_t> newNeighbors;
            gatherNeighbors(node, newNeighbors);
            if (setsHaveKUncommonElements(neighbors, newNeighbors, 1, uncommonNeighbor)) {
                return node;
            }
        }
    }
    return NONE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rax, %rcx
je 0x3fae
movq %rdi, %r15
movl $0x1, %r14d
xorl %esi, %esi
leaq 0x20(%rsp), %r13
leaq 0x8(%rsp), %rbx
movabsq $-0x5555555555555555, %r9 # imm = 0xAAAAAAAAAAAAAAAB
leaq (%rsi,%rsi,2), %rdx
movb 0x8(%rax,%rdx,4), %dil
movl 0x4(%rax,%rdx,4), %edx
notb %dil
cmpl $0x3, %edx
sete %r8b
andb %dil, %r8b
cmpl $0x4, %edx
sete %dl
orb %r8b, %dl
cmpb $0x1, %dl
jne 0x3f91
cmpb $0x1, 0x3c(%r15)
jne 0x3f06
movq 0x48(%r15), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x3fc4
movl (%rax,%rsi,4), %eax
jmp 0x3f0a
leal -0x1(%r14), %eax
movl %eax, 0xc(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0xc092
movl $0x1, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %r13, %r12
movq %r13, %rsi
movq %rbx, %rbp
movq %rbx, %rdx
movq 0x10(%rsp), %rcx
callq 0x1866d
movl %eax, %r13d
movl 0xc(%rsp), %ebx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3f75
callq 0x21a0
testb %r13b, %r13b
jne 0x3fb3
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %r12, %r13
movq %rbp, %rbx
movabsq $-0x5555555555555555, %r9 # imm = 0xAAAAAAAAAAAAAAAB
movl %r14d, %esi
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
imulq %r9, %rdx
incl %r14d
cmpq %rsi, %rdx
ja 0x3eb3
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15813(%rip), %rdi     # 0x197de
xorl %eax, %eax
callq 0x22a0
jmp 0x3fd4
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3fe6
callq 0x21a0
movq %rbx, %rdi
callq 0x2320