LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/salda[P]convex_hull_of_intersections/Ouellet_hull.cpp
// Function: Ouellet_hull::get_result()
vector<pair<double, double>> Ouellet_hull::get_result() {
	if (quadrants[0].empty())
		return {};

	vector<pair<double, double>> results;
	for (int quadrant = 0; quadrant != 4; ++quadrant)
		results.insert(results.end(), quadrants[quadrant].begin() + (quadrants[quadrant].front() == quadrants[quadrant == 0 ? 3 : quadrant - 1].back() ? 1 : 0), quadrants[quadrant].begin() + quadrants[quadrant].size());
	if (results.empty())
		return { quadrants[0][0] };
	return results;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x4340
movq %rsi, %r14
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movapd %xmm0, (%r15)
movq $0x0, 0x10(%r15)
xorl %r12d, %r12d
movl $0x3, %r13d
xorl %ebp, %ebp
leal -0x1(%rbp), %eax
testq %r12, %r12
cltq
cmoveq %r13, %rax
movq 0x18(%rsp), %rsi
leaq (%rax,%rax,2), %rax
movq 0x8(%r14,%rax,8), %rax
movq (%r14,%r12), %rdi
movq 0x8(%r14,%r12), %rcx
movsd 0x8(%rdi), %xmm0
movsd -0x8(%rax), %xmm1
movsd -0x10(%rax), %xmm2
movsd (%rdi), %xmm3
cmpeqpd %xmm2, %xmm3
cmpeqpd %xmm0, %xmm1
andpd %xmm3, %xmm1
movd %xmm1, %edx
andl $0x1, %edx
shll $0x4, %edx
addq %rdi, %rdx
movq %r15, %rdi
callq 0x45e6
incq %rbp
addq $0x18, %r12
cmpq $0x4, %rbp
jne 0x42a6
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
je 0x4352
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
jmp 0x4374
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x438b
movq (%r14), %rax
movupd (%rax), %xmm0
leaq 0x30(%rsp), %rsi
movapd %xmm0, (%rsi)
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4464
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x438b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x439f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x43b9
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/estudiante.cpp
// Function: ed::Estudiante::leerEstudiante()
void ed::Estudiante::leerEstudiante(){
   std::cout << IGREEN << "Introduce el nombre: " << RESET;
// Uso de getline para leer nombres compuestos separados por espacios
   std::getline(std::cin,this->_nombre);

// Esta sentencia no permite leer nombres compuestos con espacios en blanco
// std::cin >> this->_nombre;

   std::cout << IGREEN << "Introduce los apellidos: " << RESET;
// Uso de getline para leer los apellidos separados por espacios
   std::getline(std::cin,this->_apellidos);

// Esta sentencia no permite leer dos apellidos separados por espacios en blanco
// std::cin >> this->_apellidos;

   std::cout << IGREEN << "Introduce la nota de teoría: " << RESET;
   std::cin >> this->_teoria;

   std::cout << IGREEN << "Introduce la nota de práctica: " << RESET;
   std::cin >> this->_practica;

// Se elimina el salto de línea para evitar problemas en una posterior lectura de cadenas 
   std::cin.ignore(); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x9b4c(%rip), %r14      # 0xbfd0
leaq 0x5b7d(%rip), %rsi      # 0x8008
movl $0x7, %edx
movq %r14, %rdi
callq 0x2180
leaq 0x5b71(%rip), %rsi      # 0x8010
movl $0x15, %edx
movq %r14, %rdi
callq 0x2180
leaq 0x5b73(%rip), %r12      # 0x8026
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2180
leaq 0x8(%rbx), %r15
movq 0x9b12(%rip), %r13      # 0xbfe0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2250
movl $0x7, %edx
movq %r14, %rdi
leaq 0x5b08(%rip), %rsi      # 0x8008
callq 0x2180
leaq 0x5b1f(%rip), %rsi      # 0x802b
movl $0x19, %edx
movq %r14, %rdi
callq 0x2180
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2180
leaq 0x28(%rbx), %r15
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2250
movl $0x7, %edx
movq %r14, %rdi
leaq 0x5aa9(%rip), %r15      # 0x8008
movq %r15, %rsi
callq 0x2180
leaq 0x5ad7(%rip), %rsi      # 0x8045
movl $0x1e, %edx
movq %r14, %rdi
callq 0x2180
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2180
leaq 0x48(%rbx), %rsi
movq %r13, %rdi
callq 0x2260
movl $0x7, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
leaq 0x5ab6(%rip), %rsi      # 0x8064
movl $0x20, %edx
movq %r14, %rdi
callq 0x2180
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2180
addq $0x4c, %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2260
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/estudiante.cpp
// Function: ed::Estudiante::operator=(ed::Estudiante const&)
ed::Estudiante &ed::Estudiante::operator=(const ed::Estudiante &e){
	// Se comprueba que no sean el mismo objeto
	if (this != &e){
		this->setNombre(e.getNombre());
		this->setApellidos(e.getApellidos());

		this->setTeoria(e.getTeoria());
		this->setPractica(e.getPractica());
	}

    // Se devuelve el objeto actual
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x28eb
movq %rsi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq -0x18(%rbp), %rsi
movss %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
leaq -0x14(%rbp), %rsi
movss %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/estudiante.cpp
// Function: ed::Estudiante::operator<(ed::Estudiante const&) const
bool ed::Estudiante::operator <(const ed::Estudiante & e) const{
	if (this->getApellidos() < e.getApellidos()){
       		return true;
	}

	else if ((this->getApellidos() == e.getApellidos()) and (this->getNombre() < e.getNombre())){
     		   return true;
	}

     	else{
   		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2040
movb $0x1, %bl
testl %eax, %eax
js 0x2a0b
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %rax, %r12
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x8(%r12), %rdx
cmpq 0x8(%rax), %rdx
jne 0x2a09
testq %rdx, %rdx
je 0x29e7
movq (%rax), %rsi
movq (%r12), %rdi
callq 0x2160
testl %eax, %eax
jne 0x2a09
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2040
testl %eax, %eax
js 0x2a0b
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/estudiante.cpp
// Function: ed::operator>>(std::istream&, ed::Estudiante&)
std::istream &operator>>(std::istream &i, ed::Estudiante &e){
  std::getline(i,e._nombre);

  std::getline(i,e._apellidos);

  i >> e._teoria;
  // Se elimina el salto de línea del flujo de entrada para evitar problemas con la posterior lectura de cadenas
  i.ignore();

  i >> e._practica;
  // Se elimina el salto de línea del flujo de entrada para evitar problemas con la posterior lectura de cadenas
  i.ignore();

/* Forma alternativa para la lectura de datos numéricos usando una variable auxiliar: cadena
  std::string cadena;

  std::getline(i,cadena);
  e._teoria = atof(cadena.c_str());

  std::getline(i,cadena);
  e._practica = atof(cadena.c_str());
*/

  // Se devuelve el flujo de entrada
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %r15
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2250
leaq 0x28(%r14), %r15
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2250
leaq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x2260
movq %rbx, %rdi
callq 0x2240
addq $0x4c, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movq %rbx, %rdi
callq 0x2240
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/estudiante.cpp
// Function: ed::operator<<(std::ostream&, ed::Estudiante const&)
std::ostream &operator<<(std::ostream &o, ed::Estudiante const &e){
  o << e._nombre << std::endl;
  o << e._apellidos << std::endl;

  o << e._teoria << std::endl;
  o << e._practica << std::endl;

  // Se devuelve el flujo de salida
  return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
callq 0x2180
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %rbx, %rdi
callq 0x2180
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
cvtss2sd 0x48(%r14), %xmm0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
xorps %xmm0, %xmm0
cvtss2sd 0x4c(%r14), %xmm0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::nItems() const
int ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::nItems() const{
	int items=0;
	ed::NodoDoblementeEnlazadoEstudiante *cursor; //Creamos un cursor auxiliar para no modificar nada de la lista

	cursor=getHead(); //Empezaremos el conteo desde la cabeza

	while(cursor!=NULL){
		cursor=cursor->getNext();

		items++;
	}

	delete cursor; //Destruimos el cursor auxiliar

	return items;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x2bda
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
incl %eax
movq 0x60(%rcx), %rcx
testq %rcx, %rcx
jne 0x2bcd
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getCurrentItem() const
ed::Estudiante const & ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getCurrentItem() const{
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

	return getCurrent()->getItem();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2c00
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x10(%rax)
leaq 0x54ca(%rip), %rdi      # 0x80d1
leaq 0x54ce(%rip), %rsi      # 0x80dc
leaq 0x54f6(%rip), %rcx      # 0x810b
movl $0x2c, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getPreviousItem() const
ed::Estudiante const & ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getPreviousItem() const{
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty() and !isFirstItem());
	#endif //NDEBUG

	return getCurrent()->getPrevious()->getItem();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2c53
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x2c53
movq 0x10(%rbx), %rax
movq 0x58(%rax), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x10(%rax)
leaq 0x5516(%rip), %rdi      # 0x8170
leaq 0x547b(%rip), %rsi      # 0x80dc
leaq 0x5526(%rip), %rcx      # 0x818e
movl $0x35, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getNextItem() const
ed::Estudiante const& ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getNextItem() const{
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty() and !isLastItem());
	#endif //NDEBUG

	return getCurrent()->getNext()->getItem();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2ca5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
jne 0x2ca5
movq 0x10(%rbx), %rax
movq 0x60(%rax), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x10(%rax)
leaq 0x5548(%rip), %rdi      # 0x81f4
leaq 0x5429(%rip), %rsi      # 0x80dc
leaq 0x5557(%rip), %rcx      # 0x8211
movl $0x3e, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::isFirstItem() const
bool ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::isFirstItem() const{
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

	if(getCurrent()==getHead()){ //El cursor apunta al primer nodo de la lista
		return true;
	}

	else{ //El cursor no apunta al primer nodo de la lista
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2ce8
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x53e2(%rip), %rdi      # 0x80d1
leaq 0x53e6(%rip), %rsi      # 0x80dc
leaq 0x5576(%rip), %rcx      # 0x8273
movl $0x47, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::isLastItem() const
bool ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::isLastItem() const{
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

	if(getCurrent()->getNext()==NULL){ //El cursor apunta al ultimo nodo de la lista
		return true;
	}

	else{ //El cursor no apunta al ultimo nodo de la lista
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2d2d
movq 0x10(%rbx), %rax
cmpq $0x0, 0x60(%rax)
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x539d(%rip), %rdi      # 0x80d1
leaq 0x53a1(%rip), %rsi      # 0x80dc
leaq 0x5582(%rip), %rcx      # 0x82c4
movl $0x56, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoHead()
void ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoHead(){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

	setCurrent(getHead());

	#ifndef NDEBUG
		//Se comprueba la postcondicion
		assert(isFirstItem());
	#endif //NDEBUG
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2d7a
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x10(%rbx)
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x2d99
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5350(%rip), %rdi      # 0x80d1
leaq 0x5354(%rip), %rsi      # 0x80dc
leaq 0x5585(%rip), %rcx      # 0x8314
movl $0x65, %edx
callq 0x20e0
leaq 0x53e0(%rip), %rdi      # 0x8180
leaq 0x5335(%rip), %rsi      # 0x80dc
leaq 0x5566(%rip), %rcx      # 0x8314
movl $0x6c, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoLast()
void ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoLast(){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

	while(!isLastItem()){
		gotoNext();
	}

	#ifndef NDEBUG
		//Se comprueba la postcondicion
		assert(isLastItem());
	#endif //NDEBUG
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x2df2
leaq 0x5300(%rip), %rdi      # 0x80d1
leaq 0x5304(%rip), %rsi      # 0x80dc
leaq 0x557d(%rip), %rcx      # 0x835c
movl $0x73, %edx
callq 0x20e0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x2de9
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x2e13
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x53ea(%rip), %rdi      # 0x8204
leaq 0x52bb(%rip), %rsi      # 0x80dc
leaq 0x5534(%rip), %rcx      # 0x835c
movl $0x7c, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoPrevious()
void ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoPrevious(){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty() and !isFirstItem());
	#endif //NDEBUG

	setCurrent(getCurrent()->getPrevious());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2e64
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x2e64
movq 0x10(%rbx), %rax
movq 0x58(%rax), %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5305(%rip), %rdi      # 0x8170
leaq 0x526a(%rip), %rsi      # 0x80dc
leaq 0x552b(%rip), %rcx      # 0x83a4
movl $0x83, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoNext()
void ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoNext(){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty() and !isLastItem());
	#endif //NDEBUG

	setCurrent(getCurrent()->getNext());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2eb6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
jne 0x2eb6
movq 0x10(%rbx), %rax
movq 0x60(%rax), %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5337(%rip), %rdi      # 0x81f4
leaq 0x5218(%rip), %rsi      # 0x80dc
leaq 0x5525(%rip), %rcx      # 0x83f0
movl $0x8c, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::find(ed::Estudiante const&)
bool ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::find(ed::Estudiante  const & item){
	if(isEmpty()){ //La lista esta vacia
		return false;
	}

	else{ //La lista no esta vacia
		gotoHead(); //Empezamos la busqueda desde la cabeza de la lista

		while(!isLastItem()){ //Desplazamos el cursor hasta llegar al final de la lista
			if(item==getCurrentItem()){ //Se comprueba si se ha encontrado el item
				#ifndef NDEBUG
					//Se comprueba la postcondicion
					assert(getCurrentItem()==item);
				#endif //NDEBUG

				return true;
			}

			else{ //No se ha encontrado el item
				gotoNext();
			}
		}

		if(item==getCurrentItem()){ //Se comprueba si el ultimo elemento de la lista es el item que se esta buscando

			#ifndef NDEBUG
				//Se comprueba la postcondicion
				assert(getCurrentItem()==item);
			#endif //NDEBUG

			return true;
		}

		//No se ha encontrado el item
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2f7c
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
testb %al, %al
jne 0x2f29
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28f8
movq (%r14), %rcx
testb %al, %al
jne 0x2f83
movq %r14, %rdi
callq *0x50(%rcx)
jmp 0x2ef9
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28f8
testb %al, %al
je 0x2f7c
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x28f8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2f7e
leaq 0x56f8(%rip), %rdi      # 0x865c
leaq 0x5171(%rip), %rsi      # 0x80dc
leaq 0x54c6(%rip), %rcx      # 0x8438
movl $0xad, %edx
callq 0x20e0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq *0x10(%rcx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x28f8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2f7e
leaq 0x56b9(%rip), %rdi      # 0x865c
leaq 0x5132(%rip), %rsi      # 0x80dc
leaq 0x5487(%rip), %rcx      # 0x8438
movl $0x9e, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::remove()
void ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::remove(){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

	int old=nItems();

	if(isFirstItem() && isLastItem()){ //Solo hay un elemento en la lista
		setHead(NULL);
		setCurrent(NULL);
	}

	else if(isFirstItem()){ //Hay que borrar el primer elemento de la lista
		setHead(getCurrent()->getNext());
		getHead()->setPrevious(NULL);
		getCurrent()->setNext(NULL);
		setCurrent(getHead());
	}

	else if(isLastItem()){ //Hay que borrar el ultimo elemento de la lista
		gotoPrevious();
		getCurrent()->getNext()->setPrevious(NULL);
		getCurrent()->setNext(NULL);
	}

	else{ //Hay que borrar cualquier otro elemento de la lista
		ed::NodoDoblementeEnlazadoEstudiante * cursor=getCurrent(); //Creamos un cursor auxiliar para facilitar el proceso de borrado

		cursor->getPrevious()->setNext(cursor->getNext());
		cursor->getNext()->setPrevious(cursor->getPrevious());
		setCurrent(cursor->getNext());

		delete cursor; //Destruimos el cursor auxiliar
	}

	#ifndef NDEBUG
		//Se comprueba la postcondicion
		assert(old==nItems()+1);
	#endif //NDEBUG
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x3490
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %eax, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x3406
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x3406
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x347b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x342f
movq 0x10(%rbx), %rax
movq 0x60(%rax), %rcx
movq %rcx, 0x8(%rbx)
xorl %edx, %edx
movq %rdx, 0x58(%rcx)
movq %rdx, 0x60(%rax)
movq %rcx, 0x10(%rbx)
jmp 0x347b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x3459
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x10(%rbx), %rax
movq 0x60(%rax), %rcx
xorl %edx, %edx
movq %rdx, 0x58(%rcx)
movq %rdx, 0x60(%rax)
jmp 0x347b
movq 0x10(%rbx), %rdi
movq 0x58(%rdi), %rax
movq 0x60(%rdi), %rcx
movq %rcx, 0x60(%rax)
movq 0x60(%rdi), %rcx
movq %rax, 0x58(%rcx)
movq %rcx, 0x10(%rbx)
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
incl %eax
cmpl %eax, %r14d
jne 0x34af
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4c3a(%rip), %rdi      # 0x80d1
leaq 0x4c3e(%rip), %rsi      # 0x80dc
leaq 0x522a(%rip), %rcx      # 0x86cf
movl $0x11b, %edx            # imm = 0x11B
callq 0x20e0
leaq 0x525f(%rip), %rdi      # 0x8715
leaq 0x4c1f(%rip), %rsi      # 0x80dc
leaq 0x520b(%rip), %rcx      # 0x86cf
movl $0x13e, %edx            # imm = 0x13E
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::operator=(ed::ListaDoblementeEnlazadaOrdenadaEstudiantes&)
ed::ListaDoblementeEnlazadaOrdenadaEstudiantes &ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::operator=(ListaDoblementeEnlazadaOrdenadaEstudiantes &lista){
	int i;
	
	lista.gotoHead();
	
	while(!isEmpty()){
		remove();
	}
	
	for(i=0;i<lista.nItems();i++){
		insert(lista.getCurrentItem());
	}

	#ifndef NDEBUG
		//Se comprueba la postcondicion
		assert(getHead()==lista.getHead());
	#endif //NDEBUG

	return * this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x38(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testb %al, %al
jne 0x34fe
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
jmp 0x34e7
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
testl %eax, %eax
jle 0x3534
xorl %r15d, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x68(%rcx)
incl %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
cmpl %eax, %r15d
jl 0x350e
movq 0x8(%rbx), %rax
cmpq 0x8(%r14), %rax
jne 0x354c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51d2(%rip), %rdi      # 0x8725
leaq 0x4b82(%rip), %rsi      # 0x80dc
leaq 0x51df(%rip), %rcx      # 0x8740
movl $0x151, %edx            # imm = 0x151
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/./estudiante.hpp
// Function: ed::Estudiante::Estudiante(ed::Estudiante const&)
Estudiante(const Estudiante & e){
		this->setNombre(e.getNombre());
		this->setApellidos(e.getApellidos());

		this->setTeoria(e.getTeoria());
		this->setPractica(e.getPractica());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x86d8(%rip), %rax      # 0xbc60
movq %rax, (%rdi)
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %r12
movq %r12, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq -0x28(%rbp), %rsi
movss %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
leaq -0x24(%rbp), %rsi
movss %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3619
jmp 0x3619
movq %rax, %r14
movq 0x28(%rbx), %rdi
cmpq %r12, %rdi
je 0x362a
callq 0x2130
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x3638
callq 0x2130
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/./estudiante.hpp
// Function: ed::Estudiante::Estudiante(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float, float)
Estudiante(std::string nombre="",std::string apellidos="", float teoria=0.0, float  practica=0.0){
		this->setNombre(nombre);
		this->setApellidos(apellidos);

		this->setTeoria(teoria);
		this->setPractica(practica);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
movss %xmm0, -0x30(%rbp)
movss %xmm1, -0x2c(%rbp)
leaq 0x8441(%rip), %rax      # 0xbc60
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rbx, %rdi
callq 0x20b0
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x28(%rax)
movq (%r14), %rax
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq *0x30(%rax)
movq (%r14), %rax
leaq -0x2c(%rbp), %rsi
movq %r14, %rdi
callq *0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x28(%r14), %rdi
cmpq %r13, %rdi
je 0x3894
callq 0x2130
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x38a1
callq 0x2130
movq %r15, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/asignatura.cpp
// 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&)
ed::Estudiante const & ed::Asignatura::getEstudiante(std::string const &nombre, std::string const &apellidos){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(existeEstudiante(nombre,apellidos));
	#endif //NDEBUG

	return _lista.getCurrentItem();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x3a2d
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2bde
leaq 0x5050(%rip), %rdi      # 0x8a84
leaq 0x4e93(%rip), %rsi      # 0x88ce
leaq 0x4e9b(%rip), %rcx      # 0x88dd
movl $0x12, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/asignatura.cpp
// Function: ed::Asignatura::getEstudiante(int)
ed::Estudiante const & ed::Asignatura::getEstudiante(int indice){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(indice<=getNumeroEstudiantes());
	#endif //NDEBUG

	int i;

	_lista.gotoHead();

	for(i=0;i<indice;i++){
		_lista.gotoNext();
	}

	return _lista.getCurrentItem();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
cmpl %r14d, %eax
jl 0x3a8e
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x2d4c
testl %r14d, %r14d
jle 0x3a82
movq %rbx, %rdi
callq 0x2e84
decl %r14d
jne 0x3a75
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2bde
leaq 0x4eae(%rip), %rdi      # 0x8943
leaq 0x4e32(%rip), %rsi      # 0x88ce
leaq 0x4ebf(%rip), %rcx      # 0x8962
movl $0x1b, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/asignatura.cpp
// Function: ed::Asignatura::setEstudiante(ed::Estudiante const&)
void ed::Asignatura::setEstudiante(ed::Estudiante const &e){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(existeEstudiante(e.getNombre(),e.getApellidos()) and _lista.getCurrentItem().getNombre()==e.getNombre() and _lista.getCurrentItem().getApellidos()==e.getApellidos());
	#endif //NDEBUG

	this->_lista.setCurrentItem(e);

	#ifndef NDEBUG
		//Se comprueba la postcondicion
		assert(_lista.getCurrentItem().getNombre()==e.getNombre() and _lista.getCurrentItem().getApellidos()==e.getApellidos());
	#endif //NDEBUG
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%r14), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq *0x20(%rcx)
testb %al, %al
je 0x3bfb
addq $0x30, %r14
movq %r14, %rdi
callq 0x2bde
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%r15), %rdx
cmpq 0x8(%rax), %rdx
jne 0x3bfb
testq %rdx, %rdx
je 0x3b2e
movq (%rax), %rsi
movq (%r15), %rdi
callq 0x2160
testl %eax, %eax
jne 0x3bfb
movq %r14, %rdi
callq 0x2bde
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq 0x8(%r15), %rdx
cmpq 0x8(%rax), %rdx
jne 0x3bfb
testq %rdx, %rdx
je 0x3b71
movq (%rax), %rsi
movq (%r15), %rdi
callq 0x2160
testl %eax, %eax
jne 0x3bfb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fbc
movq %r14, %rdi
callq 0x2bde
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%r15), %rdx
cmpq 0x8(%rax), %rdx
jne 0x3c1a
testq %rdx, %rdx
je 0x3bb5
movq (%rax), %rsi
movq (%r15), %rdi
callq 0x2160
testl %eax, %eax
jne 0x3c1a
movq %r14, %rdi
callq 0x2bde
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq 0x8(%r14), %rdx
cmpq 0x8(%rax), %rdx
jne 0x3c1a
testq %rdx, %rdx
je 0x3bf0
movq (%rax), %rsi
movq (%r14), %rdi
callq 0x2160
testl %eax, %eax
jne 0x3c1a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4da1(%rip), %rdi      # 0x89a3
leaq 0x4cc5(%rip), %rsi      # 0x88ce
leaq 0x4e38(%rip), %rcx      # 0x8a48
movl $0x2c, %edx
callq 0x20e0
leaq 0x4db7(%rip), %rdi      # 0x89d8
leaq 0x4ca6(%rip), %rsi      # 0x88ce
leaq 0x4e19(%rip), %rcx      # 0x8a48
movl $0x33, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/asignatura.cpp
// 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&)
bool ed::Asignatura::borrarEstudiante(std::string const &nombre, std::string const &apellidos){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(existeEstudiante(nombre,apellidos));
	#endif //NDEBUG

	if(!existeEstudiante(nombre,apellidos)){ //No existe el estudiante a borrar
		return false;
	}

	else{ //Si existe el estudiante a borrar
		int old=getNumeroEstudiantes();

		_lista.remove();

		#ifndef NDEBUG
			//Se comprueba la postcondicion
			assert(!existeEstudiante(nombre,apellidos) and old==getNumeroEstudiantes()+1);
		#endif //NDEBUG

		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x3e9b
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0x20(%rax)
movl %eax, %r15d
testb %al, %al
je 0x3e89
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r13d
leaq 0x30(%rbx), %rdi
callq 0x33c0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0x20(%rax)
testb %al, %al
jne 0x3eba
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, %r13d
jne 0x3eba
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4be2(%rip), %rdi      # 0x8a84
leaq 0x4a25(%rip), %rsi      # 0x88ce
leaq 0x4ca4(%rip), %rcx      # 0x8b54
movl $0x54, %edx
callq 0x20e0
leaq 0x4ceb(%rip), %rdi      # 0x8bac
leaq 0x4a06(%rip), %rsi      # 0x88ce
leaq 0x4c85(%rip), %rcx      # 0x8b54
movl $0x62, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/./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){
		_nombre=nombre;

		#ifndef NDEBUG
			//Se comprueba la postcondicion
			assert(_nombre==nombre);
		#endif //NDEBUG
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x20b0
movq 0x18(%r15), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4655
testq %rdx, %rdx
je 0x464a
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x2160
testl %eax, %eax
jne 0x4655
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4600(%rip), %rdi      # 0x8c5c
leaq 0x45e8(%rip), %rsi      # 0x8c4b
leaq 0x4602(%rip), %rcx      # 0x8c6c
movl $0xbf, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/funcionesAuxiliares.cpp
// Function: ed::comprobarAsignaturaVacia(ed::Asignatura const&)
void ed::comprobarAsignaturaVacia(ed::Asignatura const &asignatura){
	std::cout << YELLOW << "La asignatura de nombre < " << asignatura.getNombre() << " > ";

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

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

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x75e6(%rip), %r14      # 0xbfd0
leaq 0x44d9(%rip), %rsi      # 0x8eca
movl $0x7, %edx
movq %r14, %rdi
callq 0x2180
leaq 0x44cd(%rip), %rsi      # 0x8ed2
movl $0x1a, %edx
movq %r14, %rdi
callq 0x2180
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 0x2180
leaq 0x44b5(%rip), %rsi      # 0x8eed
movl $0x3, %edx
movq %rax, %rdi
callq 0x2180
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4a57
callq 0x2130
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x7569(%rip), %rdi      # 0xbfd0
testb %al, %al
je 0x4a79
leaq 0x42d7(%rip), %rsi      # 0x8d49
movl $0xc, %edx
jmp 0x4a85
leaq 0x4471(%rip), %rsi      # 0x8ef1
movl $0xf, %edx
callq 0x2180
movq 0x753f(%rip), %rdi      # 0xbfd0
leaq 0x358e(%rip), %rsi      # 0x8026
movl $0x4, %edx
callq 0x2180
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 0x4ac2
callq 0x2130
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/funcionesAuxiliares.cpp
// Function: ed::cargarAsignatura(ed::Asignatura&)
void ed::cargarAsignatura(ed::Asignatura &asignatura){
  if(!asignatura.estaVacia()){ //La asignatura no esta vacia
	borrarAsignatura(asignatura); //Borramos los datos de la asignatura cargada para poder cargar otra
  }

  std::string nombreFichero;

  //Pedimos al usuario el nombre del fichero desde el cual cargar la asignatura
  std::cout << PURPLE << "Introduce el nombre del fichero " << BPURPLE << "(no olvides la extension .txt): " << RESET;
  std::cin >> nombreFichero;

  if(asignatura.cargarFichero(nombreFichero)){ //Se ha cargado la asignatura desde el fichero
	std::cout << std::endl << ICYAN << "Asignatura cargada correctamente" << RESET << std::endl;
	std::cin.ignore();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x4aec
movq %rbx, %rdi
callq 0x4c6e
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x74c9(%rip), %rdi      # 0xbfd0
leaq 0x43f3(%rip), %rsi      # 0x8f01
movl $0x7, %edx
callq 0x2180
movq 0x74b1(%rip), %rdi      # 0xbfd0
leaq 0x43e3(%rip), %rsi      # 0x8f09
movl $0x20, %edx
callq 0x2180
movq 0x7499(%rip), %rdi      # 0xbfd0
leaq 0x43ec(%rip), %rsi      # 0x8f2a
movl $0x7, %edx
callq 0x2180
movq 0x7481(%rip), %rdi      # 0xbfd0
leaq 0x43dc(%rip), %rsi      # 0x8f32
movl $0x20, %edx
callq 0x2180
movq 0x7469(%rip), %r14      # 0xbfd0
leaq 0x34b8(%rip), %rsi      # 0x8026
movl $0x4, %edx
movq %r14, %rdi
callq 0x2180
movq 0x745e(%rip), %rdi      # 0xbfe0
leaq -0x38(%rbp), %rsi
callq 0x2190
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x3eda
testb %al, %al
je 0x4c3c
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0x7413(%rip), %rdi      # 0xbfd0
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x437f(%rip), %rsi      # 0x8f53
movl $0x7, %edx
movq %rax, %rdi
callq 0x2180
leaq 0x4373(%rip), %rsi      # 0x8f5b
movl $0x20, %edx
movq %rbx, %rdi
callq 0x2180
leaq 0x342a(%rip), %rsi      # 0x8026
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x73a9(%rip), %rdi      # 0xbfe0
callq 0x2240
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4c4a
callq 0x2130
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4c66
callq 0x2130
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/funcionesAuxiliares.cpp
// Function: ed::borrarAsignatura(ed::Asignatura&)
void ed::borrarAsignatura(ed::Asignatura &asignatura){
 asignatura.setCodigo(0);
 asignatura.setNombre("");

 while(!asignatura.estaVacia()){ //Borramos estudiantes hasta que la asignatura este vacia
	asignatura.borrarEstudiante(asignatura.getEstudiante(0).getNombre(),asignatura.getEstudiante(0).getApellidos()); //Borramos a los estudiantes uno a uno
 }

 std::cout << std::endl << ICYAN << "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 0x4094(%rip), %rdx      # 0x8d29
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x396c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4cf9
callq 0x2130
jmp 0x4cf9
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq *0x50(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x4cc0
movq 0x72c3(%rip), %rbx      # 0xbfd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x4215(%rip), %rsi      # 0x8f53
movl $0x7, %edx
movq %rax, %rdi
callq 0x2180
leaq 0x43c0(%rip), %rsi      # 0x9112
movl $0x20, %edx
movq %rbx, %rdi
callq 0x2180
leaq 0x32c0(%rip), %rsi      # 0x8026
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4db6
callq 0x2130
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/./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 ListaDoblementeEnlazadaOrdenadaEstudiantes 
    		asigna los valores NULL a la cabeza y al cursor de _lista
	  	*/
  	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x4388(%rip), %rax      # 0xbd20
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r13
movq %r13, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
leaq 0x30(%rdi), %r15
leaq 0x41e2(%rip), %rax      # 0xbba0
addq $0x10, %rax
movq %rax, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq %r15, %rdi
callq 0x2bb0
testb %al, %al
je 0x7a00
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
callq *0x38(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1acf(%rip), %rdi      # 0x94d6
leaq 0x1ad8(%rip), %rsi      # 0x94e6
leaq 0x1b02(%rip), %rcx      # 0x9517
movl $0x74, %edx
callq 0x20e0
movq %rax, %r14
jmp 0x7a2f
movq %rax, %r14
movq %r15, %rdi
callq 0x7aa8
movq 0x10(%rbx), %rdi
cmpq %r13, %rdi
je 0x7a3d
callq 0x2130
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x3694
nop