LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x2050
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
movl -0x218(%rbp,%rax), %r14d
testb $0x5, %r14b
jne 0x37ab
movq (%rbx), %rax
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq -0x238(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2140
movq %rax, %rdi
callq 0x20d0
leaq -0x38(%rbp), %rdi
callq 0x2190
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
leaq -0x238(%rbp), %rdi
movl %eax, %esi
callq 0x2220
movq %rax, %rdi
callq 0x20d0
addq $0x30, %rbx
leaq -0x238(%rbp), %rsi
movq %rbx, %rdi
callq 0x306a
leaq -0x238(%rbp), %rdi
callq 0x21d0
testb $0x5, %r14b
sete %bl
leaq -0x238(%rbp), %rdi
callq 0x21e0
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37de
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2190
jmp 0x37e1
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x21e0
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::insertarEstudiante(ed::Estudiante const&)
inline bool insertarEstudiante(ed::Estudiante const &estudiante){
		//Precondición
		#ifndef NDEBUG
			assert(!existeEstudiante(estudiante));
		#endif

		int old=getNumeroEstudiantes();

		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(estudiante) 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
leaq 0x30(%rdi), %r13
movq %r13, %rdi
callq 0x2a80
testb %al, %al
jne 0x392e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r15d
movq %r13, %rdi
movq %r14, %rsi
callq 0x2a80
movl %eax, %r12d
testb %al, %al
jne 0x3918
movq %r13, %rdi
movq %r14, %rsi
callq 0x2cc2
movq %r13, %rdi
movq %r14, %rsi
callq 0x2a80
testb %al, %al
je 0x394d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
decl %eax
cmpl %eax, %r15d
jne 0x394d
xorb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3de1(%rip), %rdi      # 0x7716
leaq 0x3df8(%rip), %rsi      # 0x7734
leaq 0x3e02(%rip), %rcx      # 0x7745
movl $0x141, %edx            # imm = 0x141
callq 0x2110
leaq 0x3e31(%rip), %rdi      # 0x7785
leaq 0x3dd9(%rip), %rsi      # 0x7734
leaq 0x3de3(%rip), %rcx      # 0x7745
movl $0x14f, %edx            # imm = 0x14F
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7403(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x3dd7(%rip), %rsi      # 0x79b0
movq %rax, %rdi
callq 0x2160
movq %rax, %r14
movq (%rbx), %rax
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
leaq 0x3dcc(%rip), %rsi      # 0x79d2
movq %rax, %rdi
callq 0x2160
leaq -0x38(%rbp), %rdi
callq 0x2190
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x3c12(%rip), %rcx      # 0x7839
leaq 0x3da8(%rip), %rsi      # 0x79d6
testb %al, %al
cmovneq %rcx, %rsi
movq 0x7395(%rip), %rdi      # 0xafd0
callq 0x2160
leaq 0x4158(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/funcionesAuxiliares.cpp
// Function: ed::cargarAsignatura(ed::Asignatura&)
void ed::cargarAsignatura(ed::Asignatura &asignatura){
	if(!asignatura.estaVacia()){ //La asignatura no está vacía
		borrarAsignatura(asignatura); //Borramos la asignatura
	}

	std::string nombreFichero;

	//Pedimos al usuario el nombre del fichero con la información de la asignatura a cargar
	std::cout << std::endl << YELLOW << "Introduzca el nombre del fichero " << BIYELLOW << "(no olvide la extensión .txt): " << RESET;
	std::cin >> nombreFichero;

	if(!asignatura.cargarFichero(nombreFichero)){ //No se ha podido cargar la asignatura
		std::cout << std::endl << BIRED << "Error: no se pudo abrir el fichero" << RESET << std::endl;
		std::cin.ignore();
	}

	else{ //Se ha podido cargar la asignatura
		std::cout << std::endl << CYAN << "Asignatura cargada correctamente" << RESET << std::endl;
		std::cin.ignore();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x3c94
movq %rbx, %rdi
callq 0x3db8
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x7325(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x3d2f(%rip), %rsi      # 0x79e6
movq %rax, %rdi
callq 0x2160
leaq 0x3d28(%rip), %rsi      # 0x79ee
movq %rax, %rdi
callq 0x2160
leaq 0x3d3b(%rip), %rsi      # 0x7a10
movq %rax, %rdi
callq 0x2160
leaq 0x3dd2(%rip), %rsi      # 0x7ab6
movq %rax, %rdi
callq 0x2160
leaq 0x40ac(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq 0x72de(%rip), %rdi      # 0xafe0
leaq -0x28(%rbp), %rsi
callq 0x21a0
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x34f8
testb %al, %al
je 0x3d3f
movq 0x72ae(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x3d15(%rip), %rsi      # 0x7a43
movq %rax, %rdi
callq 0x2160
leaq 0x3d0e(%rip), %rsi      # 0x7a4b
jmp 0x3d61
movq 0x728a(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x3cc6(%rip), %rsi      # 0x7a18
movq %rax, %rdi
callq 0x2160
leaq 0x3cbf(%rip), %rsi      # 0x7a20
movq %rax, %rdi
callq 0x2160
leaq 0x402f(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq 0x7259(%rip), %rdi      # 0xafe0
callq 0x2240
leaq -0x28(%rbp), %rdi
callq 0x2190
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
xorl %esi, %esi
callq *0x38(%rax)
leaq 0x3a3c(%rip), %rsi      # 0x7811
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x20a0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
leaq -0x38(%rbp), %rdi
callq 0x2190
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
jne 0x3e13
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5508
jmp 0x3dfa
movq 0x71b6(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x3c1d(%rip), %rsi      # 0x7a43
movq %rax, %rdi
callq 0x2160
leaq 0x3de8(%rip), %rsi      # 0x7c1d
movq %rax, %rdi
callq 0x2160
leaq 0x3f5b(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/funcionesAuxiliares.cpp
// Function: ed::grabarAsignatura(ed::Asignatura&)
void ed::grabarAsignatura(ed::Asignatura  &asignatura){
	if(asignatura.estaVacia()){ //La asignatura está vacía
		std::cout << std::endl << BIRED << "Error: no hay ningún estudiante cargado" << RESET << std::endl;
	}

	else{ //La asignatura no está vacía
		std::string nombreFichero;

		//Pedimos al usuario el nombre del fichero en el que grabar la información de la asignatura
		std::cout << std::endl << BIYELLOW << "Introduzca el nombre del fichero (no olvide la extensión .txt): " << RESET;
		std::cin >> nombreFichero;

		if(!asignatura.grabarFichero(nombreFichero)){ //No se ha podido grabar la asignatura
			std::cout << std::endl << std::endl << BIRED << "Error: no se pudo abrir el fichero" << RESET << std::endl;
		}

		else{ //Se ha podido grabar la asignatura
			std::cout << std::endl << CYAN << "Asignatura grabada correctamente" << RESET << std::endl;
			std::cin.ignore();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x3ed6
movq 0x713a(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x3b76(%rip), %rsi      # 0x7a18
movq %rax, %rdi
callq 0x2160
leaq 0x3bbb(%rip), %rsi      # 0x7a6c
movq %rax, %rdi
callq 0x2160
leaq 0x3edf(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x20d0
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x70e3(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x3b17(%rip), %rsi      # 0x7a10
movq %rax, %rdi
callq 0x2160
leaq 0x3b8d(%rip), %rsi      # 0x7a95
movq %rax, %rdi
callq 0x2160
leaq 0x3e88(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq 0x70ba(%rip), %rdi      # 0xafe0
leaq -0x28(%rbp), %rsi
callq 0x21a0
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x36f4
testb %al, %al
je 0x3f8e
movq 0x708a(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x3af1(%rip), %rsi      # 0x7a43
movq %rax, %rdi
callq 0x2160
leaq 0x3b76(%rip), %rsi      # 0x7ad7
movq %rax, %rdi
callq 0x2160
leaq 0x3e2f(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq 0x7059(%rip), %rdi      # 0xafe0
callq 0x2240
jmp 0x3fd7
movq 0x703b(%rip), %rdi      # 0xafd0
callq 0x20d0
movq %rax, %rdi
callq 0x20d0
leaq 0x3a6f(%rip), %rsi      # 0x7a18
movq %rax, %rdi
callq 0x2160
leaq 0x3a68(%rip), %rsi      # 0x7a20
movq %rax, %rdi
callq 0x2160
leaq 0x3dd8(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
leaq -0x28(%rbp), %rdi
callq 0x2190
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/funcionesAuxiliares.cpp
// Function: ed::consultarAsignatura(ed::Asignatura&)
void ed::consultarAsignatura(ed::Asignatura  &asignatura){
	if(asignatura.estaVacia()){ //La asignatura está vacía
		std::cout << std::endl << BIRED << "Error: no hay ningún estudiante cargado" << RESET << std::endl;
	}

	else{ //La asignatura no está vacía
		//Mostramos la información de la asignatura
		std::cout << std::endl << BBLUE << "Código de la asignatura: " << BLUE << asignatura.getCodigo() << RESET << std::endl << std::endl;
		std::cout << BBLUE << "Nombre de la asignatura: " << BLUE << asignatura.getNombre() << RESET << std::endl << std::endl;
		std::cout << BBLUE << "Lista de estudiantes de la asignatura:" << BLUE << std::endl;

		asignatura.consultarEstudiantes();
		
		std::cout << RESET;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %r14d
movq 0x6fab(%rip), %rdi      # 0xafd0
callq 0x20d0
testb %r14b, %r14b
je 0x4070
leaq 0x39e2(%rip), %rsi      # 0x7a18
movq %rax, %rdi
callq 0x2160
leaq 0x3a27(%rip), %rsi      # 0x7a6c
movq %rax, %rdi
callq 0x2160
leaq 0x3d4b(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
leaq 0x3009(%rip), %r14      # 0x7080
movq %rax, %rdi
movq %r14, %rsi
callq 0x2160
leaq 0x3a6f(%rip), %rsi      # 0x7af8
movq %rax, %rdi
callq 0x2160
leaq 0x2ff9(%rip), %r15      # 0x7091
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %r12, %rdi
movl %eax, %esi
callq 0x2220
leaq 0x3ce0(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x20d0
movq 0x6ef2(%rip), %rdi      # 0xafd0
movq %r14, %rsi
callq 0x2160
leaq 0x3a26(%rip), %rsi      # 0x7b13
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %r14
movq (%rbx), %rax
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
leaq 0x3c7a(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x20d0
leaq -0x40(%rbp), %rdi
callq 0x2190
movq 0x6e83(%rip), %r14      # 0xafd0
leaq 0x2f2c(%rip), %rsi      # 0x7080
movq %r14, %rdi
callq 0x2160
leaq 0x39ca(%rip), %rsi      # 0x7b2d
movq %rax, %rdi
callq 0x2160
leaq 0x2f1f(%rip), %rsi      # 0x7091
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x2ffe
leaq 0x3c0a(%rip), %rsi      # 0x7d9f
movq %r14, %rdi
callq 0x2160
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/funcionesAuxiliares.cpp
// Function: ed::insertarEstudianteEnAsignatura(ed::Asignatura&)
void ed::insertarEstudianteEnAsignatura(ed::Asignatura &asignatura){
	ed::Estudiante estudiante;

	std::cout << std::endl << BIYELLOW << "Introduzca los datos del estudiante" << RESET << std::endl;
	estudiante.leerEstudiante(); //Pedimos al usuario la información del estudiante a insertar

	if(!asignatura.existeEstudiante(estudiante)){ //No existe el estudiante indicado por el usuario
		if(!asignatura.insertarEstudiante(estudiante)){ //No se ha podido insertar el estudiante
			std::cout << std::endl << BIRED << "Error: no se ha podido insertar el estudiante indicado" << RESET << std::endl;
		}

		else{ //Se ha podido insertar el estudiante
			std::cout << std::endl << CYAN << "Estudiante insertado correctamente" << RESET << std::endl;
		}
	}

	else{ //Existe el estudiante indicado por el usuario
		std::cout << std::endl << BIRED << "Error: ya existe el estudiante indicado" << RESET << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x2ef4(%rip), %rsi      # 0x7811
leaq -0x50(%rbp), %rdi
leaq -0xa(%rbp), %rdx
callq 0x20a0
leaq 0x2ee0(%rip), %rsi      # 0x7811
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x20a0
leaq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x37fe
leaq -0x30(%rbp), %rdi
callq 0x2190
leaq -0x50(%rbp), %rdi
callq 0x2190
movq 0x665f(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x3093(%rip), %rsi      # 0x7a10
movq %rax, %rdi
callq 0x2160
leaq 0x332c(%rip), %rsi      # 0x7cb8
movq %rax, %rdi
callq 0x2160
leaq 0x3404(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
leaq -0xa0(%rbp), %rdi
callq 0x245c
leaq 0x30(%rbx), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2a80
testb %al, %al
je 0x49ef
movq 0x65fe(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x303a(%rip), %rsi      # 0x7a18
movq %rax, %rdi
callq 0x2160
leaq 0x3349(%rip), %rsi      # 0x7d36
jmp 0x4a48
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq 0x38ac
testb %al, %al
je 0x4a26
movq 0x65c7(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x302e(%rip), %rsi      # 0x7a43
movq %rax, %rdi
callq 0x2160
leaq 0x32ef(%rip), %rsi      # 0x7d13
jmp 0x4a48
movq 0x65a3(%rip), %rdi      # 0xafd0
callq 0x20d0
leaq 0x2fdf(%rip), %rsi      # 0x7a18
movq %rax, %rdi
callq 0x2160
leaq 0x3294(%rip), %rsi      # 0x7cdc
movq %rax, %rdi
callq 0x2160
leaq 0x3348(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
leaq -0xa0(%rbp), %rdi
callq 0x3198
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2190
jmp 0x4a93
movq %rax, %rbx
jmp 0x4aad
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2190
jmp 0x4aad
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x3198
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::borrarEstudiante(int)
inline bool borrarEstudiante(int pos){
		//Precondición
		#ifndef NDEBUG
			assert(pos<=getNumeroEstudiantes());
		#endif

		int old=getNumeroEstudiantes();

		if(pos>getNumeroEstudiantes()){ //La posición es mayor que el número de estudiantes
			return false;
		}

		else{ //La posición no es mayor que el número de estudiantes
			_arbol.remove(_arbol.getEstudiante(pos)); //Borramos el estudiante en la posición indicada

			//Postcondición
			#ifndef NDEBUG
				assert(old==getNumeroEstudiantes()+1);
			#endif

			return true;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x18(%rax)
cmpl %ebx, %eax
jl 0x557f
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl %eax, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl %eax, %r12d
cmpl %ebx, %eax
jl 0x556a
leaq 0x30(%r14), %r13
movq %r13, %rdi
movl %ebx, %esi
callq 0x2b54
movq %r13, %rdi
movq %rax, %rsi
callq 0x2dec
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, %r15d
jne 0x559e
cmpl %ebx, %r12d
setge %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29a9(%rip), %rdi      # 0x7f2f
leaq 0x21a7(%rip), %rsi      # 0x7734
leaq 0x29b7(%rip), %rcx      # 0x7f4b
movl $0x1ad, %edx            # imm = 0x1AD
callq 0x2110
leaq 0x2a9a(%rip), %rdi      # 0x803f
leaq 0x2188(%rip), %rsi      # 0x7734
leaq 0x2998(%rip), %rcx      # 0x7f4b
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5671
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r15d
leaq 0x30(%rbx), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2a80
movl %eax, %r12d
testb %al, %al
je 0x565f
movq %r13, %rdi
movq %r14, %rsi
callq 0x2dec
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 0x5690
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, %r15d
jne 0x5690
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28fe(%rip), %rdi      # 0x7f76
leaq 0x20b5(%rip), %rsi      # 0x7734
leaq 0x2933(%rip), %rcx      # 0x7fb9
movl $0x18a, %edx            # imm = 0x18A
callq 0x2110
leaq 0x2960(%rip), %rdi      # 0x7ff7
leaq 0x2096(%rip), %rsi      # 0x7734
leaq 0x2914(%rip), %rcx      # 0x7fb9
movl $0x198, %edx            # imm = 0x198
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::setEstudiante(ed::Estudiante const&)
inline void setEstudiante(ed::Estudiante const &e){
		//Precondición
		#ifndef NDEBUG
			assert(existeEstudiante(e));
		#endif

		_arbol.setEstudiante(e); //Modificamos el estudiante

		//Postcondición
		#ifndef NDEBUG
			assert(existeEstudiante(e));
		#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %r14
movq %r14, %rdi
callq 0x2a80
testb %al, %al
je 0x56ec
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c10
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a80
testb %al, %al
je 0x570b
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x296a(%rip), %rdi      # 0x805d
leaq 0x203a(%rip), %rsi      # 0x7734
leaq 0x2970(%rip), %rcx      # 0x8071
movl $0x100, %edx            # imm = 0x100
callq 0x2110
leaq 0x294b(%rip), %rdi      # 0x805d
leaq 0x201b(%rip), %rsi      # 0x7734
leaq 0x2951(%rip), %rcx      # 0x8071
movl $0x107, %edx            # imm = 0x107
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %r12
leaq 0x5206(%rip), %rax      # 0xad30
movq %rax, (%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x10(%rdi), %rbx
movb $0x0, 0x20(%rdi)
leaq 0x30(%rdi), %r15
leaq 0x5103(%rip), %rax      # 0xac50
movq %rax, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
callq 0x5e24
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x40(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x32a4
movq %rbx, %rdi
callq 0x2190
movq %r14, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %rdi
callq 0x21b0
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x21b0
leaq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x37fe
leaq -0x30(%rbp), %rdi
callq 0x2190
leaq -0x50(%rbp), %rdi
callq 0x2190
addq $0x30, %rbx
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq 0x2a80
movl %eax, %ebx
leaq -0xa0(%rbp), %rdi
callq 0x3198
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x3198
jmp 0x5cd7
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2190
jmp 0x5cce
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x5d82
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x21b0
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x21b0
leaq -0xa8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x37fe
leaq -0x38(%rbp), %rdi
callq 0x2190
leaq -0x58(%rbp), %rdi
callq 0x2190
addq $0x30, %rbx
leaq -0xa8(%rbp), %rsi
movq %rbx, %rdi
callq 0x2ade
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x3198
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2514(%rip), %rdi      # 0x829d
leaq 0x19a4(%rip), %rsi      # 0x7734
leaq 0x23c3(%rip), %rcx      # 0x815a
movl $0x9a, %edx
callq 0x2110
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x3198
jmp 0x5dcc
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2190
jmp 0x5dc3
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e04
addq $0x30, %r14
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2b54
leaq 0x23b5(%rip), %rdi      # 0x81c0
leaq 0x1922(%rip), %rsi      # 0x7734
leaq 0x23c6(%rip), %rcx      # 0x81df
movl $0xc5, %edx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e3f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x23da(%rip), %rdi      # 0x8220
leaq 0x18e7(%rip), %rsi      # 0x7734
leaq 0x23e0(%rip), %rcx      # 0x8234
movl $0xdd, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20e0
movq (%r14), %rax
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x8(%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2990
testb %al, %al
je 0x5ead
leaq -0x38(%rbp), %rdi
callq 0x2190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1674(%rip), %rdi      # 0x7528
leaq 0x1879(%rip), %rsi      # 0x7734
leaq 0x239e(%rip), %rcx      # 0x8260
movl $0xef, %edx
callq 0x2110
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x98, %rsp
movss %xmm1, -0x2c(%rbp)
movss %xmm0, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x5fe6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r14d
leaq -0x70(%rbp), %rdi
movq %r12, %rsi
callq 0x21b0
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x21b0
leaq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
callq 0x37fe
leaq -0x50(%rbp), %rdi
callq 0x2190
movl %r14d, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2190
leaq 0x30(%rbx), %r14
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x2a80
movl %eax, %r13d
testb %al, %al
jne 0x5fc1
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x2cc2
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x6005
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
decl %eax
cmpl %eax, -0x2c(%rbp)
jne 0x6005
xorb $0x1, %r13b
leaq -0xc0(%rbp), %rdi
callq 0x3198
movl %r13d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22af(%rip), %rdi      # 0x829c
leaq 0x1740(%rip), %rsi      # 0x7734
leaq 0x22c5(%rip), %rcx      # 0x82c0
movl $0x11d, %edx            # imm = 0x11D
callq 0x2110
leaq 0x231c(%rip), %rdi      # 0x8328
leaq 0x1721(%rip), %rsi      # 0x7734
leaq 0x22a6(%rip), %rcx      # 0x82c0
movl $0x12c, %edx            # imm = 0x12C
callq 0x2110
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2190
jmp 0x6035
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2190
jmp 0x604f
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3198
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x614c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r14d
leaq -0x70(%rbp), %rdi
movq %r12, %rsi
callq 0x21b0
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x21b0
leaq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x37fe
leaq -0x50(%rbp), %rdi
callq 0x2190
movl %r14d, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2190
leaq 0x30(%rbx), %r14
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x2a80
movl %eax, %r13d
testb %al, %al
je 0x612b
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x2dec
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x20(%rax)
testb %al, %al
jne 0x616b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, -0x2c(%rbp)
jne 0x616b
leaq -0xc0(%rbp), %rdi
callq 0x3198
movl %r13d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x214a(%rip), %rdi      # 0x829d
leaq 0x15da(%rip), %rsi      # 0x7734
leaq 0x220c(%rip), %rcx      # 0x836d
movl $0x166, %edx            # imm = 0x166
callq 0x2110
leaq 0x2253(%rip), %rdi      # 0x83c5
leaq 0x15bb(%rip), %rsi      # 0x7734
leaq 0x21ed(%rip), %rcx      # 0x836d
movl $0x175, %edx            # imm = 0x175
callq 0x2110
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2190
jmp 0x619b
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2190
jmp 0x61b5
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3198
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movups %xmm0, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
callq 0x9b18
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x9be8
movl 0x38(%r15), %eax
movl %eax, 0x38(%rbx)
movb 0x3c(%r15), %al
movb %al, 0x3c(%rbx)
pushq $0x18
popq %rdi
callq 0x2190
movq %rax, %r12
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x9caa
movq %r12, 0x18(%rbx)
cmpb $0x1, 0x3c(%r15)
jne 0x25b9
pushq $0x38
popq %rdi
callq 0x2190
movq %rax, %r12
movq 0x40(%r15), %rsi
movq %rax, %rdi
callq 0xa9b8
movq %r12, 0x40(%rbx)
pushq $0x18
popq %rdi
callq 0x2190
movq %rax, %r12
movq 0x48(%r15), %rsi
movq %rax, %rdi
callq 0x9caa
movq %r12, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x25c9
jmp 0x25c9
movq %rax, %r15
movq %r12, %rdi
callq 0x2160
jmp 0x25d9
movq %rax, %r15
movq %r14, %rdi
callq 0xb872
movq %rbx, %rdi
callq 0xb864
movq %r15, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x267d
movq %rsi, %r14
movq %rbx, %rdi
callq 0x9b18
leaq 0x20(%r14), %rsi
leaq 0x20(%rbx), %rdi
callq 0x9be8
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
movb 0x3c(%r14), %al
movb %al, 0x3c(%rbx)
pushq $0x18
popq %rdi
callq 0x2190
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x9caa
movq %r15, 0x18(%rbx)
cmpb $0x1, 0x3c(%r14)
jne 0x267d
pushq $0x38
popq %rdi
callq 0x2190
movq %rax, %r15
movq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0xa9b8
movq %r15, 0x40(%rbx)
pushq $0x18
popq %rdi
callq 0x2190
movq %rax, %r15
movq 0x48(%r14), %rsi
movq %rax, %rdi
callq 0x9caa
movq %r15, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x268a
jmp 0x268a
movq %rax, %rbx
movq %r15, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26b6
movq %r14, %rdi
callq 0xb872
movq %r14, %rdi
callq 0x2160
cmpb $0x1, 0x3c(%rbx)
jne 0x26f6
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x26d5
movq %r14, %rdi
callq 0xac1a
movq %r14, %rdi
callq 0x2160
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x26ee
movq %r14, %rdi
callq 0xb872
movq %r14, %rdi
callq 0x2160
leaq 0x20(%rbx), %rdi
callq 0xb872
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb864
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r13
orl $-0x1, (%rsi)
movq %rdi, %r12
andl $0x0, (%rdx)
movq (%rdi), %r8
xorl %edi, %edi
pushq $0xc
popq %r14
xorl %ebp, %ebp
movq %rcx, (%rsp)
movl %ebp, %esi
movq 0x8(%r12), %rax
subq %r8, %rax
cqto
idivq %r14
cmpq %rsi, %rax
jbe 0x27bd
imulq $0xc, %rsi, %rbx
cmpb $0x0, 0x8(%r8,%rbx)
jne 0x27b9
leaq (%r8,%rbx), %rax
cmpl %edi, 0x4(%rax)
jbe 0x27b9
cmpb $0x1, 0x3c(%r12)
movl %ebp, %eax
jne 0x27a2
movq 0x48(%r12), %rdi
callq 0x9e18
movq (%rsp), %rcx
movl (%rax), %eax
movq (%r12), %r8
movl %eax, (%r13)
movl 0x4(%r8,%rbx), %edi
movl %edi, (%r15)
movl (%rcx), %eax
cmpl $-0x1, %eax
je 0x27b9
cmpl %eax, %edi
jae 0x27bd
incl %ebp
jmp 0x275b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
orl $-0x1, (%rsi)
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
pushq $0xc
popq %rdi
cqto
idivq %rdi
xorl %edx, %edx
pushq $-0x1
popq %rdi
movl %edx, %edx
cmpq %rdx, %rax
jbe 0x2827
imulq $0xc, %rdx, %r8
cmpb $0x0, 0x8(%rcx,%r8)
jne 0x2823
addq %rcx, %r8
movl 0x4(%r8), %r8d
testl %r8d, %r8d
setne %r9b
cmpl %edi, %r8d
setb %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x2823
movl %r8d, (%rsi)
movl %r8d, %edi
cmpl $0x3, %r8d
jb 0x2827
incl %edx
jmp 0x27e6
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
movq 0x8(%rdi), %rax
subq %rsi, %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
xorl %ecx, %ecx
xorl %edx, %edx
movl %edx, %edx
cmpq %rdx, %rax
jbe 0x285a
imulq $0xc, %rdx, %rdi
cmpb $0x0, 0x8(%rsi,%rdi)
jne 0x2856
addq %rsi, %rdi
addl 0x4(%rdi), %ecx
incl %edx
jmp 0x283e
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getNumberOfDegreeNeighbors(unsigned int const&, unsigned int const&, unsigned int const&) const
uint32_t Graph::getNumberOfDegreeNeighbors(const uint32_t &node, const uint32_t &degree, const uint32_t &atLeast) const {
    uint32_t count = 0;
    uint32_t pos = (!mapping ? node : idToPos->at(node));
    uint32_t neighborCount = nodeIndex[pos].edges;
    uint32_t nextNodeOffset = (pos == nodeIndex.size()-1 ? edgeBuffer->size() : nodeIndex[pos+1].offset);
    for (uint32_t i = nodeIndex[pos].offset ; i < nextNodeOffset && neighborCount ; i++) {
        uint32_t nPos = (!mapping ? (*edgeBuffer)[i] : idToPos->at((*edgeBuffer)[i]));
        if (!nodeIndex[nPos].removed) {
            neighborCount--;
            if (nodeIndex[nPos].edges == degree) {
                count++;
                if (atLeast && count == atLeast) {
                    break;
                }
            }
        }
    }
    return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, %r15
cmpb $0x1, 0x3c(%rdi)
jne 0x288b
movq 0x40(%r15), %rdi
callq 0xb880
movq %rax, %rsi
movl (%rsi), %r8d
movq (%r15), %rcx
movq 0x8(%r15), %rax
imulq $0xc, %r8, %rdi
leaq (%rcx,%rdi), %rsi
subq %rcx, %rax
pushq $0xc
popq %r9
cqto
idivq %r9
decq %rax
cmpq %r8, %rax
jne 0x28c2
movq 0x18(%r15), %rdx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
shrq $0x2, %rax
jmp 0x28cc
incl %r8d
imulq $0xc, %r8, %rax
movl (%rcx,%rax), %eax
movl 0x4(%rcx,%rdi), %r12d
movl (%rsi), %r13d
movl %eax, %ebx
leaq (,%r13,4), %r14
xorl %ebp, %ebp
cmpq %rbx, %r13
jae 0x2954
testl %r12d, %r12d
je 0x2954
cmpb $0x0, 0x3c(%r15)
je 0x2909
movq 0x18(%r15), %rax
movq 0x40(%r15), %rdi
movq (%rax), %rsi
addq %r14, %rsi
callq 0xb880
movq (%r15), %rcx
jmp 0x2913
movq 0x18(%r15), %rax
movq (%rax), %rax
addq %r14, %rax
movl (%rax), %eax
imulq $0xc, %rax, %rax
cmpb $0x0, 0x8(%rcx,%rax)
jne 0x294b
addq %rcx, %rax
decl %r12d
movl 0x4(%rax), %eax
movq 0x10(%rsp), %rdx
cmpl (%rdx), %eax
jne 0x294b
incl %ebp
movq 0x8(%rsp), %rax
movl (%rax), %eax
testl %eax, %eax
sete %dl
cmpl %eax, %ebp
setne %al
orb %dl, %al
cmpb $0x1, %al
jne 0x2954
incq %r13
addq $0x4, %r14
jmp 0x28e0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa2ac
cmpl $-0x1, %eax
je 0x35d8
movl %eax, %ebp
cmpb $0x1, 0x3c(%r14)
jne 0x355c
movq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0xb880
movq %rax, %r15
movl (%r15), %ecx
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
pushq $0xc
popq %rdi
cqto
idivq %rdi
decq %rax
cmpq %rcx, %rax
jne 0x358d
movq 0x18(%r14), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %r15
subq %rax, %r15
shrq $0x2, %r15
jmp 0x359e
incl %ecx
imulq $0xc, %rcx, %rax
movl (%rsi,%rax), %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 0x35bd
leaq (%rax,%rcx,4), %rdi
callq 0x2290
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 0x13b52(%rip), %rdi     # 0x17131
leaq 0x13a60(%rip), %rsi     # 0x17046
leaq 0x13b53(%rip), %rcx     # 0x17140
movl $0x139, %edx            # imm = 0x139
callq 0x2100
nop