LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x377b
addq $0x30, %r14
movq %r14, %rdi
callq 0x2982
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x377b
movq %r14, %rdi
callq 0x2982
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x377b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d3e
movq %r14, %rdi
callq 0x2982
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x3794
movq %r14, %rdi
callq 0x2982
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x3794
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31f7(%rip), %rdi      # 0x6979
leaq 0x311b(%rip), %rsi      # 0x68a4
leaq 0x328e(%rip), %rcx      # 0x6a1e
pushq $0x2c
jmp 0x37ab
leaq 0x3213(%rip), %rdi      # 0x69ae
leaq 0x3102(%rip), %rsi      # 0x68a4
leaq 0x3275(%rip), %rcx      # 0x6a1e
pushq $0x33
popq %rdx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/asignatura.cpp
// 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)
bool ed::Asignatura::insertarEstudiante(std::string const &nombre, std::string const &apellidos,float teoria, float practica){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!existeEstudiante(nombre,apellidos));
	#endif //NDEBUG

	int old=getNumeroEstudiantes();

	if(existeEstudiante(nombre,apellidos)){ //Ya existe el estudiante a insertar
		return false;
	}

	else{ //No existe el estudiante a insertar
		Estudiante estudiante(nombre,apellidos,teoria,practica);

		this->_lista.insert(estudiante);

		#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
subq $0x98, %rsp
movss %xmm1, -0x30(%rbp)
movss %xmm0, -0x2c(%rbp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x38ad
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x20(%rax)
movl %eax, %r14d
testb %al, %al
jne 0x3894
leaq -0x70(%rbp), %rdi
movq %r13, %rsi
callq 0x21b0
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x21b0
leaq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movss -0x2c(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
callq 0x34aa
leaq -0x50(%rbp), %rdi
callq 0x2190
leaq -0x70(%rbp), %rdi
callq 0x2190
leaq 0x30(%rbx), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x2eee
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x38c6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
decl %eax
cmpl %eax, %r15d
jne 0x38c6
leaq -0xc0(%rbp), %rdi
callq 0x3322
xorb $0x1, %r14b
movl %r14d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31a5(%rip), %rdi      # 0x6a59
leaq 0x2fe9(%rip), %rsi      # 0x68a4
leaq 0x31bb(%rip), %rcx      # 0x6a7d
pushq $0x3a
jmp 0x38dd
leaq 0x3218(%rip), %rdi      # 0x6ae5
leaq 0x2fd0(%rip), %rsi      # 0x68a4
leaq 0x31a2(%rip), %rcx      # 0x6a7d
pushq $0x4a
popq %rdx
callq 0x2110
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2190
jmp 0x38f4
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2190
jmp 0x390e
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3322
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x336e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x399f
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0x20(%rax)
movl %eax, %r15d
testb %al, %al
je 0x398d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r13d
leaq 0x30(%rbx), %rdi
callq 0x30a0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0x20(%rax)
testb %al, %al
jne 0x39b8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %eax
cmpl %eax, %r13d
jne 0x39b8
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30b4(%rip), %rdi      # 0x6a5a
leaq 0x2ef7(%rip), %rsi      # 0x68a4
leaq 0x3176(%rip), %rcx      # 0x6b2a
pushq $0x54
jmp 0x39cf
leaq 0x31c3(%rip), %rdi      # 0x6b82
leaq 0x2ede(%rip), %rsi      # 0x68a4
leaq 0x315d(%rip), %rcx      # 0x6b2a
pushq $0x62
popq %rdx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/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;
	int i;

	fichero.open(nombreFichero.c_str()); //Abrimos el fichero

	if(!fichero){ //No se ha podido abrir el fichero
		std::cout << std::endl << ONIRED << "Error: no se pudo crear o encontrar el fichero" << RESET << std::endl;
		std::cin.ignore();

		return false;
	}

	//Grabamos el nombre y el codigo de la asignatura
	fichero << getNombre() << std::endl;
	fichero << getCodigo() << std::endl;

	//Grabamos la lista de estudiantes
	for(i=0;i<getNumeroEstudiantes();i++){
		fichero << getEstudiante(i);
	}

	fichero.close(); //Cerramos el fichero

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x240(%rbp), %r15
movq %r15, %rdi
callq 0x2210
movq (%r14), %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x2050
movq -0x240(%rbp), %rax
movq -0x18(%rax), %rax
movl -0x220(%rbp,%rax), %r12d
testb $0x5, %r12b
je 0x3d02
movq 0x6319(%rip), %rdi      # 0x9fd0
callq 0x20d0
leaq 0x2f05(%rip), %rsi      # 0x6bc8
movq %rax, %rdi
callq 0x2160
leaq 0x2f20(%rip), %rsi      # 0x6bf2
movq %rax, %rdi
callq 0x2160
leaq 0x2345(%rip), %rsi      # 0x6026
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq 0x62e8(%rip), %rdi      # 0x9fe0
callq 0x2240
jmp 0x3d87
movq (%rbx), %rax
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq -0x240(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2140
movq %rax, %rdi
callq 0x20d0
leaq -0x40(%rbp), %rdi
callq 0x2190
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
leaq -0x240(%rbp), %rdi
movl %eax, %esi
callq 0x2220
movq %rax, %rdi
callq 0x20d0
xorl %r14d, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
cmpl %eax, %r14d
jge 0x3d7b
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x30(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x28ac
incl %r14d
jmp 0x3d51
leaq -0x240(%rbp), %rdi
callq 0x21d0
testb $0x5, %r12b
sete %bl
leaq -0x240(%rbp), %rdi
callq 0x21e0
movl %ebx, %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3dbe
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2190
jmp 0x3dc1
jmp 0x3dbe
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x21e0
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x336e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %r14
movq %r14, %rdi
callq 0x20e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2912
testb %al, %al
je 0x3f17
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2d14(%rip), %rdi      # 0x6c32
leaq 0x2cfc(%rip), %rsi      # 0x6c21
leaq 0x2d16(%rip), %rcx      # 0x6c42
movl $0xbf, %edx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e46(%rip), %rdi      # 0x9fd0
leaq 0x2d11(%rip), %rsi      # 0x6ea2
callq 0x2160
leaq 0x2d0d(%rip), %rsi      # 0x6eaa
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 0x2cfb(%rip), %rsi      # 0x6ec5
movq %rax, %rdi
callq 0x2160
leaq -0x38(%rbp), %rdi
callq 0x2190
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x2b36(%rip), %rcx      # 0x6d21
leaq 0x2cd7(%rip), %rsi      # 0x6ec9
testb %al, %al
cmovneq %rcx, %rsi
movq 0x5dd1(%rip), %rdi      # 0x9fd0
callq 0x2160
leaq 0x1e1b(%rip), %rsi      # 0x6026
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 0x336e
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x4258
movq %rbx, %rdi
callq 0x4350
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x5d61(%rip), %rdi      # 0x9fd0
leaq 0x2c63(%rip), %rsi      # 0x6ed9
callq 0x2160
leaq 0x2c5f(%rip), %rsi      # 0x6ee1
movq %rax, %rdi
callq 0x2160
leaq 0x2c71(%rip), %rsi      # 0x6f02
movq %rax, %rdi
callq 0x2160
leaq 0x2c6a(%rip), %rsi      # 0x6f0a
movq %rax, %rdi
callq 0x2160
leaq 0x1d77(%rip), %rsi      # 0x6026
movq %rax, %rdi
callq 0x2160
movq 0x5d22(%rip), %rdi      # 0x9fe0
leaq -0x28(%rbp), %rsi
callq 0x21a0
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x39d6
testb %al, %al
je 0x4324
movq 0x5cf2(%rip), %rdi      # 0x9fd0
callq 0x20d0
leaq 0x2c41(%rip), %rsi      # 0x6f2b
movq %rax, %rdi
callq 0x2160
leaq 0x2c3a(%rip), %rsi      # 0x6f33
movq %rax, %rdi
callq 0x2160
leaq 0x1d1e(%rip), %rsi      # 0x6026
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq 0x5cc1(%rip), %rdi      # 0x9fe0
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 0x336e
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
xorl %esi, %esi
callq *0x38(%rax)
leaq 0x2994(%rip), %rsi      # 0x6d01
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 0x43da
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)
jmp 0x4392
movq 0x5bef(%rip), %rdi      # 0x9fd0
callq 0x20d0
leaq 0x2b3e(%rip), %rsi      # 0x6f2b
movq %rax, %rdi
callq 0x2160
leaq 0x2cee(%rip), %rsi      # 0x70ea
movq %rax, %rdi
callq 0x2160
leaq 0x1c1b(%rip), %rsi      # 0x6026
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 0x336e
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/funcionesAuxiliares.cpp
// Function: ed::grabarAsignatura(ed::Asignatura&)
void ed::grabarAsignatura(ed::Asignatura  &asignatura){
  std::string nombreFichero;

  std::cout << PURPLE << "Introduce el nombre del fichero " << BPURPLE << "(no olvides la extension .txt): " << RESET;
  std::cin >> nombreFichero;

  if(asignatura.estaVacia()){ //La asignatura esta vacia
	std::cout << std::endl << ONIRED << "Error: no hay ninguna asignatura cargada" << RESET << std::endl;
	std::cin.ignore();
  }

  else{ //La asignatura no esta vacia
	if(asignatura.grabarFichero(nombreFichero)){ //Se ha grabado la asignatura en el fichero
		std::cout << std::endl << ICYAN << "Asignatura grabada correctamente" << RESET << std::endl;
		std::cin.ignore();
	}
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x5b6d(%rip), %rdi      # 0x9fd0
leaq 0x2a6f(%rip), %rsi      # 0x6ed9
callq 0x2160
leaq 0x2a6b(%rip), %rsi      # 0x6ee1
movq %rax, %rdi
callq 0x2160
leaq 0x2a7d(%rip), %rsi      # 0x6f02
movq %rax, %rdi
callq 0x2160
leaq 0x2a76(%rip), %rsi      # 0x6f0a
movq %rax, %rdi
callq 0x2160
leaq 0x1b83(%rip), %rsi      # 0x6026
movq %rax, %rdi
callq 0x2160
movq 0x5b2e(%rip), %rdi      # 0x9fe0
leaq -0x28(%rbp), %rsi
callq 0x21a0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x44ec
movq 0x5b01(%rip), %rdi      # 0x9fd0
callq 0x20d0
leaq 0x26ed(%rip), %rsi      # 0x6bc8
movq %rax, %rdi
callq 0x2160
leaq 0x2a6a(%rip), %rsi      # 0x6f54
jmp 0x451e
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x3c62
testb %al, %al
je 0x4549
movq 0x5acd(%rip), %rdi      # 0x9fd0
callq 0x20d0
leaq 0x2a1c(%rip), %rsi      # 0x6f2b
movq %rax, %rdi
callq 0x2160
leaq 0x2a5f(%rip), %rsi      # 0x6f7d
movq %rax, %rdi
callq 0x2160
leaq 0x1af9(%rip), %rsi      # 0x6026
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq 0x5a9c(%rip), %rdi      # 0x9fe0
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 0x336e
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/funcionesAuxiliares.cpp
// Function: ed::insertarEstudianteEnAsignatura(ed::Asignatura&)
void ed::insertarEstudianteEnAsignatura(ed::Asignatura &asignatura){
	Estudiante estudiante;
	
	estudiante.leerEstudiante(); //Pedimos al usuario toda la informacion del estudiante a insertar

	if(!asignatura.existeEstudiante(estudiante.getNombre(),estudiante.getApellidos())){
		if(asignatura.insertarEstudiante(estudiante.getNombre(),estudiante.getApellidos(),estudiante.getTeoria(),estudiante.getPractica())){ //Insertamos al estudiante
			std::cout << std::endl << ICYAN << "Estudiante insertado correctamente" << RESET << std::endl;
		}
		
		else{
			std::cout << std::endl << ONIRED << "Error: no ha podido insertarse el estudiante" << RESET << std::endl;
		}
	}
	
	else{
		std::cout << std::endl << ONIRED << "Error: ya existe el estudiante indicado" << RESET << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x1e5a(%rip), %rsi      # 0x6d01
leaq -0x60(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0x20a0
leaq 0x1e46(%rip), %rsi      # 0x6d01
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x20a0
leaq -0xb0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x34aa
leaq -0x40(%rbp), %rdi
callq 0x2190
leaq -0x60(%rbp), %rdi
callq 0x2190
leaq -0xb0(%rbp), %rdi
callq 0x245c
leaq -0xa8(%rbp), %r14
leaq -0x88(%rbp), %r15
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x4f45
movq 0x50a8(%rip), %rdi      # 0x9fd0
callq 0x20d0
leaq 0x1c94(%rip), %rsi      # 0x6bc8
movq %rax, %rdi
callq 0x2160
leaq 0x22ad(%rip), %rsi      # 0x71f0
jmp 0x4fa8
movss -0x68(%rbp), %xmm0
movss -0x64(%rbp), %xmm1
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x48(%rax)
testb %al, %al
je 0x4f86
movq 0x5067(%rip), %rdi      # 0x9fd0
callq 0x20d0
leaq 0x1fb6(%rip), %rsi      # 0x6f2b
movq %rax, %rdi
callq 0x2160
leaq 0x221c(%rip), %rsi      # 0x71a0
jmp 0x4fa8
movq 0x5043(%rip), %rdi      # 0x9fd0
callq 0x20d0
leaq 0x1c2f(%rip), %rsi      # 0x6bc8
movq %rax, %rdi
callq 0x2160
leaq 0x221b(%rip), %rsi      # 0x71c3
movq %rax, %rdi
callq 0x2160
leaq 0x106f(%rip), %rsi      # 0x6026
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
leaq -0xb0(%rbp), %rdi
callq 0x3322
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2190
jmp 0x4ff7
movq %rax, %rbx
jmp 0x5011
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2190
jmp 0x5011
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x3322
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x336e
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x3f47(%rip), %rax      # 0x9d20
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rdx, %r15
movl %esi, %r12d
movb $0x0, 0x20(%rdi)
leaq 0x30(%rdi), %r14
movq %r14, %rdi
callq 0x5ea0
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
callq *0x38(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x40(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x5e34
movq %rax, %r15
movq %r14, %rdi
callq 0x5ee2
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x2190
movq %r15, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x336e
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::CMolecularSystem()
CMolecularSystem::CMolecularSystem()
{
  this->fillConstants();
  this->parameter = new CParameter;
  this->parameter->nop = -1;
  this->is_listcreated = -1;
  for (int i = 0;i<OrderParameterHistoSize;i++)
  {
    this->q4Histo[i] = 0;
    this->q6Histo[i] = 0;
    this->aq4Histo[i] = 0;
    this->aq6Histo[i] = 0;
    this->normq4 = 0;
    this->normq6 = 0;
    this->normaq4 = 0;
    this->normaq6 = 0;
  }
  for (int i = 0;i<OrderParameterHistoSize;i++)
  {
     for (int j = 0;j<OrderParameterHistoSize;j++)
     {
       this->q46Histo3d[i][j] = 0;
       this->aq46Histo3d[i][j] = 0;

     }
  }
  clear_Q4Q6Histograms();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x74bb(%rip), %rax      # 0x9d18
movq %rax, (%rdi)
callq 0x2926
movl $0x3258, %edi           # imm = 0x3258
callq 0x21d0
movq %rax, %r14
movq %rax, %rdi
callq 0x6900
movq %r14, 0xb4e8c0(%rbx)
orl $-0x1, 0x3208(%r14)
orl $-0x1, 0x20(%rbx)
leaq 0x7a50a4(%rbx), %rax
movl $0xbc1, %ecx            # imm = 0xBC1
xorps %xmm0, %xmm0
cmpq $0xfa9, %rcx            # imm = 0xFA9
je 0x28c9
andl $0x0, -0x2ee0(%rbx,%rcx,4)
andl $0x0, -0x1f40(%rbx,%rcx,4)
andl $0x0, -0xfa0(%rbx,%rcx,4)
andl $0x0, (%rbx,%rcx,4)
movups %xmm0, (%rax)
incq %rcx
jmp 0x289c
leaq 0x3d47a4(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x3e8, %rcx            # imm = 0x3E8
je 0x2902
xorl %edx, %edx
cmpq $0x3e8, %rdx            # imm = 0x3E8
je 0x28f7
andl $0x0, -0x3d0900(%rax,%rdx,4)
andl $0x0, (%rax,%rdx,4)
incq %rdx
jmp 0x28dd
incq %rcx
addq $0xfa0, %rax            # imm = 0xFA0
jmp 0x28d2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2e86
movq %rax, %rbx
movl $0x3258, %esi           # imm = 0x3258
movq %r14, %rdi
callq 0x21e0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::clear_Q4Q6Histograms()
void CMolecularSystem::clear_Q4Q6Histograms()
{
  for (int ti = 0;ti<Q4SIZE;ti++)
  {
    for (int tj = 0;tj<Q6SIZE;tj++)
    {
      this->QBCC[ti][tj] = 0.0;
      this->QFCC[ti][tj] = 0.0;
      this->QHCP[ti][tj] = 0.0;
      this->QLIQ[ti][tj] = 0.0;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addq $0xa642b8, %rdi         # imm = 0xA642B8
xorl %eax, %eax
cmpq $0xc8, %rax
je 0x2ed7
xorl %ecx, %ecx
cmpq $0x258, %rcx            # imm = 0x258
je 0x2ecb
andq $0x0, -0x2bf200(%rdi,%rcx,8)
andq $0x0, -0x1d4c00(%rdi,%rcx,8)
andq $0x0, -0xea600(%rdi,%rcx,8)
andq $0x0, (%rdi,%rcx,8)
incq %rcx
jmp 0x2e9d
incq %rax
addq $0x12c0, %rdi           # imm = 0x12C0
jmp 0x2e93
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::~CMolecularSystem()
CMolecularSystem::~CMolecularSystem()
{
  delete parameter;
  delete [] molecules;
  delete [] cellHead;
  delete [] cellList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6e26(%rip), %rax      # 0x9d18
movq %rax, (%rdi)
movq 0xb4e8c0(%rdi), %rdi
testq %rdi, %rdi
je 0x2f07
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xb4e8b8(%rbx), %r15
testq %r15, %r15
je 0x2f53
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x2f40
addq $-0x870, %r15           # imm = 0xF790
imulq $0x870, %r12, %r13      # imm = 0x870
leaq (%r15,%r13), %rdi
callq 0x68b0
addq $-0x870, %r13           # imm = 0xF790
jne 0x2f2e
imulq $0x870, %r12, %rsi      # imm = 0x870
orq $0x8, %rsi
movq %r14, %rdi
callq 0x2390
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2f61
callq 0x2250
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x2f7d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::initializeMolecules()
void CMolecularSystem::initializeMolecules()
{
  try {
    if (this->parameter->nop <0) {throw NumberOfParticlesNotDefinedException();}
    else {
      this->molecules   = new CMolecule[this->parameter->nop];

    }
  } catch(NumberOfParticlesNotDefinedException& ) {}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xb4e8c0(%rdi), %rax
movslq 0x3208(%rax), %r12
testq %r12, %r12
js 0x3113
movq %rdi, -0x38(%rbp)
imulq $0x870, %r12, %rbx      # imm = 0x870
orq $0x8, %rbx
movq %rbx, %rdi
callq 0x2030
movq %r12, (%rax)
movq %rax, -0x30(%rbp)
leaq 0x8(%rax), %r14
testl %r12d, %r12d
je 0x30f9
imulq $-0x870, %r12, %r15     # imm = 0xF790
xorl %r13d, %r13d
movq %r14, %r12
movq %r12, %rdi
callq 0x6898
addq $-0x870, %r13           # imm = 0xF790
addq $0x870, %r12            # imm = 0x870
cmpq %r13, %r15
jne 0x30de
movq -0x38(%rbp), %rax
movq %r14, 0xb4e8b8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x2110
leaq 0x6c16(%rip), %rsi      # 0x9d38
movq %rax, %rdi
xorl %edx, %edx
callq 0x2320
movq %rdx, %r12
movq %rax, %r15
jmp 0x316b
movq %rdx, %r12
movq %rax, %r15
testq %r13, %r13
je 0x315f
negq %r13
movq -0x30(%rbp), %r14
addq $-0x868, %r14           # imm = 0xF798
leaq (%r14,%r13), %rdi
callq 0x68b0
addq $-0x870, %r13           # imm = 0xF790
jne 0x314d
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x2390
movq %r15, %rdi
cmpl $0x1, %r12d
jne 0x318c
callq 0x20f0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22f0
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::InitializeSystem()
void CMolecularSystem::InitializeSystem()
{
  if (this->parameter->xyzFile.compare("notset") == 0) {
    cerr << "xyzFilename must be set in parameter.txt\nif you want to create a fcc use CREATEFCC as filename\n";}
  else
  {
    if (this->parameter->xyzFile.compare(CREATEFCCSTRING) == 0)
    {
      this->createFCC();
    } else if (this->parameter->xyzFile.compare(CREATEBCCSTRING) == 0)
    {
      this->createBCC();
    } else if (this->parameter->xyzFile.compare(CREATEHCPSTRING) == 0)
    {
      this->createHCP();
    } else {
      this->readParticleFile();
    }


  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x3230, %r14d          # imm = 0x3230
movq 0xb4e8c0(%rdi), %rdi
addq %r14, %rdi
leaq 0x3ec3(%rip), %rsi      # 0x70de
callq 0x20e0
testl %eax, %eax
je 0x3284
addq 0xb4e8c0(%rbx), %r14
leaq 0x6fce(%rip), %rsi      # 0xa200
movq %r14, %rdi
callq 0x2040
testl %eax, %eax
je 0x329b
movl $0x3230, %r14d          # imm = 0x3230
movq 0xb4e8c0(%rbx), %rdi
addq %r14, %rdi
leaq 0x6fcb(%rip), %rsi      # 0xa220
callq 0x2040
testl %eax, %eax
je 0x32a7
addq 0xb4e8c0(%rbx), %r14
leaq 0x6fd4(%rip), %rsi      # 0xa240
movq %r14, %rdi
callq 0x2040
movq %rbx, %rdi
testl %eax, %eax
je 0x32b3
popq %rbx
popq %r14
popq %rbp
jmp 0x3838
movq 0x6d65(%rip), %rdi      # 0x9ff0
leaq 0x3e53(%rip), %rsi      # 0x70e5
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x32bc
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3452
popq %rbx
popq %r14
popq %rbp
jmp 0x35e4
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::createFCC()
void CMolecularSystem::createFCC()
{
  int t;
  int bu;
  bu = this->parameter->baseunit;
  if (bu != -1)
  {
    if (parameter->nop != -1) {cerr << "how comes that numberofparticles is already set in createfcc?\n";}
    this->parameter->nop = 4*bu*bu*bu;
    this->initializeMolecules(4*bu*bu*bu);
    for (int jz=0; jz < 2*bu ; jz++)
    {
      for (int jy=0; jy < 2*bu ; jy++)
      {
        for (int jx = 0; jx < bu; jx++)
        {
          t = 2*bu*bu*jz + bu*jy + jx;
          this->molecules[t].posx = double(jx)*this->parameter->boxx/double(bu) + this->parameter->boxx/double(2*bu) * ((jz+jy) % 2);
          this->molecules[t].posy = double(jy)*this->parameter->boxy/double(2*bu);
          this->molecules[t].posz = double(jz)*this->parameter->boxz/double(2*bu);
        }
      }
    }
  } else { cerr << "baseunit is not set, which is needed for createFCC\n";}
  setNumberOfCells();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb4e8c0(%rdi), %rax
movl 0x320c(%rax), %r14d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %r14
je 0x3428
cmpl $-0x1, 0x3208(%rax)
je 0x330c
movq 0x6cf7(%rip), %rdi      # 0x9ff0
leaq 0x3e69(%rip), %rsi      # 0x7169
callq 0x21b0
movq 0xb4e8c0(%rbx), %rax
movl %r14d, %r15d
imull %r15d, %r15d
movl %r14d, %esi
imull %r15d, %esi
shll $0x2, %esi
movl %esi, 0x3208(%rax)
movq %rbx, %rdi
callq 0x2faa
cvtsi2sd %r14d, %xmm0
leal (%r14,%r14), %eax
cvtsi2sd %eax, %xmm1
xorl %ecx, %ecx
testl %r14d, %r14d
movl $0x0, %edx
cmovgl %r14d, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
addl %r15d, %r15d
xorpd %xmm2, %xmm2
movsd 0x3ca9(%rip), %xmm3     # 0x7008
xorl %edi, %edi
cmpl %esi, %edi
je 0x343b
xorl %r8d, %r8d
xorpd %xmm4, %xmm4
movq %rcx, %r9
cmpl %eax, %r8d
je 0x341a
movq 0xb4e8b8(%rbx), %r10
movq 0xb4e8c0(%rbx), %r11
leal (%r8,%rdi), %r12d
andl $0x1, %r12d
cvtsi2sd %r12d, %xmm5
xorl %r12d, %r12d
cmpq %r12, %rdx
je 0x340b
leal (%r9,%r12), %r13d
cvtsi2sd %r12d, %xmm6
movsd 0x3218(%r11), %xmm7
mulsd %xmm7, %xmm6
divsd %xmm0, %xmm6
divsd %xmm1, %xmm7
mulsd %xmm5, %xmm7
addsd %xmm6, %xmm7
movslq %r13d, %r13
imulq $0x870, %r13, %r13      # imm = 0x870
movsd %xmm7, 0x8(%r10,%r13)
movsd 0x3220(%r11), %xmm6
mulsd %xmm4, %xmm6
divsd %xmm1, %xmm6
movsd %xmm6, 0x10(%r10,%r13)
movsd 0x3228(%r11), %xmm6
mulsd %xmm2, %xmm6
divsd %xmm1, %xmm6
movsd %xmm6, 0x18(%r10,%r13)
incq %r12
jmp 0x339a
addsd %xmm3, %xmm4
incl %r8d
addq %r14, %r9
jmp 0x3373
addsd %xmm3, %xmm2
incl %edi
addq %r15, %rcx
jmp 0x3361
movq 0x6bc1(%rip), %rdi      # 0x9ff0
leaq 0x3d72(%rip), %rsi      # 0x71a8
callq 0x21b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b2a
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::createBCC()
void CMolecularSystem::createBCC()
{
  int t;
  int bu;
  bu = this->parameter->baseunit;
  if (bu != -1)
  {
    if (parameter->nop != -1) {cerr << "how comes that numberofparticles is already set in createbcc?\n";}
    this->parameter->nop = 2*bu*bu*bu;
    this->initializeMolecules(2*bu*bu*bu);
    for (int jz=0; jz < 2*bu ; jz++)
    {
      for (int jy=0; jy < bu ; jy++)
      {
        for (int jx = 0; jx < bu; jx++)
        {
          t = bu*bu*jz + bu*jy + jx;
          this->molecules[t].posx = double(jx)*this->parameter->boxx/double(bu) + this->parameter->boxx/double(2*bu) * (jz % 2);
          this->molecules[t].posy = double(jy)*this->parameter->boxy/double(bu) + this->parameter->boxy/double(2*bu) * (jz % 2);
          this->molecules[t].posz = double(jz)*this->parameter->boxz/double(2*bu);
        }
      }
    }
  } else { cerr << "baseunit is not set, which is needed for createBCC\n";}
  setNumberOfCells();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xb4e8c0(%rdi), %rax
movl 0x320c(%rax), %r14d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %r14
je 0x35c0
cmpl $-0x1, 0x3208(%rax)
je 0x349f
movq 0x6b64(%rip), %rdi      # 0x9ff0
leaq 0x3d49(%rip), %rsi      # 0x71dc
callq 0x21b0
movq 0xb4e8c0(%rbx), %rax
leal (%r14,%r14), %r15d
movl %r14d, %r12d
imull %r12d, %r12d
movl %r12d, %esi
imull %r15d, %esi
movl %esi, 0x3208(%rax)
movq %rbx, %rdi
callq 0x2faa
cvtsi2sd %r14d, %xmm0
cvtsi2sd %r15d, %xmm1
xorl %eax, %eax
testl %r14d, %r14d
movl $0x0, %ecx
cmovgl %r14d, %ecx
testl %r15d, %r15d
cmovlel %eax, %r15d
xorpd %xmm2, %xmm2
movsd 0x3b1e(%rip), %xmm3     # 0x7008
xorl %edx, %edx
cmpl %r15d, %edx
je 0x35d3
movl %edx, %esi
andl $0x1, %esi
cvtsi2sd %esi, %xmm4
xorl %esi, %esi
xorpd %xmm5, %xmm5
movq %rax, %rdi
cmpl %ecx, %esi
je 0x35b2
movq 0xb4e8b8(%rbx), %r8
movq 0xb4e8c0(%rbx), %r9
xorl %r10d, %r10d
cmpq %r10, %r14
je 0x35a4
leal (%rdi,%r10), %r11d
cvtsi2sd %r10d, %xmm6
movsd 0x3218(%r9), %xmm7
mulsd %xmm7, %xmm6
divsd %xmm0, %xmm6
divsd %xmm1, %xmm7
mulsd %xmm4, %xmm7
addsd %xmm6, %xmm7
movslq %r11d, %r11
imulq $0x870, %r11, %r11      # imm = 0x870
movsd %xmm7, 0x8(%r8,%r11)
movsd 0x3220(%r9), %xmm6
movapd %xmm6, %xmm7
mulsd %xmm5, %xmm7
divsd %xmm0, %xmm7
divsd %xmm1, %xmm6
mulsd %xmm4, %xmm6
addsd %xmm7, %xmm6
movsd %xmm6, 0x10(%r8,%r11)
movsd 0x3228(%r9), %xmm6
mulsd %xmm2, %xmm6
divsd %xmm1, %xmm6
movsd %xmm6, 0x18(%r8,%r11)
incq %r10
jmp 0x3520
addsd %xmm3, %xmm5
incl %esi
addq %r14, %rdi
jmp 0x3507
addsd %xmm3, %xmm2
incl %edx
addq %r12, %rax
jmp 0x34ec
movq 0x6a29(%rip), %rdi      # 0x9ff0
leaq 0x3c4d(%rip), %rsi      # 0x721b
callq 0x21b0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3b2a
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::createLists()
void CMolecularSystem::createLists()
{
  int noc;
  if (this->is_listcreated == -1)
  {
    noc = this->parameter->noc;
    cellList = new int[this->parameter->nop];
    cellHead = new int[noc*noc*noc];
    neighborcells = new SNeighborCells[noc*noc*noc];
    fillNeighborCells();
    this->is_listcreated = 1;

  }
}

// Assembly:
cmpl $-0x1, 0x20(%rdi)
je 0x3f91
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb4e8c0(%rdi), %rax
movl 0x3214(%rax), %r15d
movslq 0x3208(%rax), %rax
leaq (,%rax,4), %rdi
testq %rax, %rax
pushq $-0x1
popq %r14
cmovsq %r14, %rdi
callq 0x2030
movq %rax, 0x8(%rbx)
movl %r15d, %eax
imull %r15d, %eax
imull %r15d, %eax
movslq %eax, %r15
leaq (,%r15,4), %rdi
testl %r15d, %r15d
cmovsq %r14, %rdi
callq 0x2030
movq %rax, %rcx
pushq $0x68
popq %rdx
movq %r15, %rax
mulq %rdx
movq %rcx, 0x10(%rbx)
cmovnoq %rax, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x3c86
movl $0x1, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::fillLists()
void CMolecularSystem::fillLists()
{
  int cell,allCells,noc;
  createLists();

  noc = this->parameter->noc;
  allCells = noc*noc*noc;
  for(int ti=0;ti<this->parameter->nop;ti++)
  {
    cellList[ti] = nilvalue;
  }
  for (int ci=0;ci<allCells;ci++)
  {
    cellHead[ci] = nilvalue;
  }
  for(int ti=0;ti<this->parameter->nop;ti++)
  {
    cell = get_cellByIndex(ti);
    this->molecules[ti].cell = cell;
    cellList[ti] = cellHead[cell];
    cellHead[cell] = ti;
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3f8a
movq 0xb4e8c0(%rbx), %r15
movl 0x3214(%r15), %ecx
movl %ecx, %eax
imull %eax, %eax
movq %rbx, -0x30(%rbp)
movq 0x8(%rbx), %rdx
xorl %esi, %esi
movslq 0x3208(%r15), %rdi
cmpq %rdi, %rsi
jge 0x4135
movl $0x1fca055, (%rdx,%rsi,4) # imm = 0x1FCA055
incq %rsi
jmp 0x411d
imull %ecx, %eax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x4158
movl $0x1fca055, (%rcx,%rdx,4) # imm = 0x1FCA055
incq %rdx
jmp 0x4147
movq -0x30(%rbp), %rax
movq 0x8(%rax), %r12
movq 0x10(%rax), %r13
movl $0x554, %ebx            # imm = 0x554
addq 0xb4e8b8(%rax), %rbx
xorl %r14d, %r14d
movslq 0x3208(%r15), %rax
cmpq %rax, %r14
jge 0x41a9
movq -0x30(%rbp), %rdi
movl %r14d, %esi
callq 0x402c
movl %eax, (%rbx)
cltq
movl (%r13,%rax,4), %ecx
movl %ecx, (%r12,%r14,4)
movl %r14d, (%r13,%rax,4)
incq %r14
addq $0x870, %rbx            # imm = 0x870
jmp 0x4173
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_AllNeighbors()
void CMolecularSystem::get_AllNeighbors()
{
  double nd,d;
  nd = this->parameter->neighbordistance;
  int c,nop;
  nop = this->parameter->nop;

  for (int ti = 0;ti<nop;ti++)
  {
    for (int tn = 0;tn<MAXNUMBEROFNEIGHBORS;tn++)
    {
      this->molecules[ti].neighbors[tn] = nilvalue;
      this->molecules[ti].neighbordist[tn] = -1.0;
    }
  }


  for (int ti = 0;ti<nop;ti++)
  {
    c = 0;
	  for (int tj = 0;tj<nop;tj++)
	  {

          if (tj != ti) { 
            d = get_absDistance(ti,tj); 
            if (d < nd) {
              this->molecules[ti].neighbors[c] = tj; 
              this->molecules[ti].neighbordist[c]=d; 
              c += 1;   
            }
         }
	  }
    this->molecules[ti].n_neighbors = c;
    cout << ti << " " << c << "\n";
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0xb4e8b8(%rdi), %rax
movq %rdi, -0x30(%rbp)
movq 0xb4e8c0(%rdi), %rcx
movsd 0x3250(%rcx), %xmm0
movsd %xmm0, -0x48(%rbp)
movl 0x3208(%rcx), %r13d
xorl %ecx, %ecx
testl %r13d, %r13d
movl $0x0, %r8d
cmovgl %r13d, %r8d
pushq $0x46
popq %rdx
movabsq $-0x4010000000000000, %rsi # imm = 0xBFF0000000000000
cmpq %r8, %rcx
je 0x4238
movq %rdx, %rdi
cmpq $0xaa, %rdi
je 0x422d
movl $0x1fca055, -0x78(%rax,%rdi,4) # imm = 0x1FCA055
movq %rsi, (%rax,%rdi,8)
incq %rdi
jmp 0x4213
incq %rcx
addq $0x870, %rax            # imm = 0x870
jmp 0x420b
xorl %r14d, %r14d
movq %r8, -0x38(%rbp)
cmpq %r8, %r14
je 0x4303
xorl %r12d, %r12d
imulq $0x870, %r14, %rcx      # imm = 0x870
movq -0x30(%rbp), %rax
movq 0xb4e8b8(%rax), %rbx
movq %rcx, -0x40(%rbp)
addq %rcx, %rbx
xorl %r15d, %r15d
cmpl %r12d, %r13d
je 0x42a8
cmpq %r12, %r14
je 0x42a3
movq -0x30(%rbp), %rdi
movl %r14d, %esi
movl %r12d, %edx
callq 0x4312
movsd -0x48(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x42a3
movslq %r15d, %r15
movl %r12d, 0xa0(%rbx,%r15,4)
movsd %xmm0, 0x230(%rbx,%r15,8)
incl %r15d
incq %r12
jmp 0x4267
movq -0x30(%rbp), %rax
movq 0xb4e8b8(%rax), %rax
movq -0x40(%rbp), %rcx
movl %r15d, 0x550(%rax,%rcx)
movq 0x5d0a(%rip), %rdi      # 0x9fd0
movl %r14d, %esi
callq 0x2330
movq %rax, %rdi
leaq 0x2e8f(%rip), %rsi      # 0x7167
callq 0x21b0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2330
movq %rax, %rdi
leaq 0x3088(%rip), %rsi      # 0x737a
callq 0x21b0
incq %r14
movq -0x38(%rbp), %r8
jmp 0x423f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_absDistance(int, int)
double CMolecularSystem::get_absDistance(int ti ,int tj)
{
  double abs,diffx,diffy,diffz;
  diffx = this->molecules[tj].posx - this->molecules[ti].posx;
  diffy = this->molecules[tj].posy - this->molecules[ti].posy;
  diffz = this->molecules[tj].posz - this->molecules[ti].posz;
  //nearest image
  if (diffx >  this->parameter->boxx/2.0) {diffx = diffx - this->parameter->boxx;};
  if (diffx < -this->parameter->boxx/2.0) {diffx = diffx + this->parameter->boxx;};
  if (diffy >  this->parameter->boxy/2.0) {diffy = diffy - this->parameter->boxy;};
  if (diffy < -this->parameter->boxy/2.0) {diffy = diffy + this->parameter->boxy;};
  if (diffz >  this->parameter->boxz/2.0) {diffz = diffz - this->parameter->boxz;};
  if (diffz < -this->parameter->boxz/2.0) {diffz = diffz + this->parameter->boxz;};
  abs = sqrt(diffx*diffx + diffy*diffy + diffz*diffz);
  return abs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rax
imulq $0x870, %rax, %rcx      # imm = 0x870
movslq %esi, %rax
imulq $0x870, %rax, %rdx      # imm = 0x870
movq 0xb4e8b8(%rdi), %rsi
movq 0xb4e8c0(%rdi), %rax
movsd 0x8(%rsi,%rcx), %xmm1
subsd 0x8(%rsi,%rdx), %xmm1
movsd 0x10(%rsi,%rcx), %xmm5
subsd 0x10(%rsi,%rdx), %xmm5
movsd 0x18(%rsi,%rcx), %xmm2
subsd 0x18(%rsi,%rdx), %xmm2
movsd 0x3218(%rax), %xmm6
movsd 0x3220(%rax), %xmm4
movsd 0x2ca4(%rip), %xmm0     # 0x7018
movapd %xmm6, %xmm7
mulsd %xmm0, %xmm7
movapd %xmm1, %xmm3
subsd %xmm6, %xmm3
cmpltsd %xmm1, %xmm7
andpd %xmm7, %xmm3
andnpd %xmm1, %xmm7
orpd %xmm3, %xmm7
movsd 0x2c9b(%rip), %xmm3     # 0x7038
movapd %xmm6, %xmm8
mulsd %xmm3, %xmm8
addsd %xmm7, %xmm6
movapd %xmm7, %xmm1
cmpltsd %xmm8, %xmm1
andpd %xmm1, %xmm6
andnpd %xmm7, %xmm1
orpd %xmm6, %xmm1
movapd %xmm4, %xmm6
mulsd %xmm0, %xmm6
movapd %xmm5, %xmm7
subsd %xmm4, %xmm7
cmpltsd %xmm5, %xmm6
andpd %xmm6, %xmm7
andnpd %xmm5, %xmm6
orpd %xmm7, %xmm6
movapd %xmm4, %xmm7
mulsd %xmm3, %xmm7
addsd %xmm6, %xmm4
movapd %xmm6, %xmm5
cmpltsd %xmm7, %xmm5
andpd %xmm5, %xmm4
andnpd %xmm6, %xmm5
orpd %xmm4, %xmm5
movsd 0x3228(%rax), %xmm4
mulsd %xmm4, %xmm0
movapd %xmm2, %xmm6
subsd %xmm4, %xmm6
cmpltsd %xmm2, %xmm0
andpd %xmm0, %xmm6
andnpd %xmm2, %xmm0
orpd %xmm6, %xmm0
mulsd %xmm4, %xmm3
addsd %xmm0, %xmm4
movapd %xmm0, %xmm2
cmpltsd %xmm3, %xmm2
andpd %xmm2, %xmm4
andnpd %xmm0, %xmm2
orpd %xmm4, %xmm2
mulsd %xmm5, %xmm5
mulsd %xmm1, %xmm1
addsd %xmm5, %xmm1
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
sqrtsd %xmm2, %xmm0
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::PLM(int, int, double)
double CMolecularSystem::PLM(int l, int m, double x)
{
  double fact,pll,pmm,pmmp1,somx2;
  int i,ll;
  pll = 0.0;
  if (m < 0 || m > l || fabs(x) > 1.0)
  cerr << "impossible combination of l and m" << "\n";
  pmm=1.0;
  if (m > 0)
  {
    somx2=sqrt((1.0-x)*(1.0+x));
    fact=1.0;
    for (i=1;i<=m;i++)
    {
      pmm *= -fact*somx2;
      fact += 2.0;
    }
  }
  if (l == m)
    return pmm;
  else
  {
    pmmp1=x*(2*m+1)*pmm;
    if (l == (m+1))
      return pmmp1;
    else
    {
      for (ll=m+2;ll<=l;ll++)
        {
          pll=(x*(2*ll-1)*pmmp1-(ll+m-1)*pmm)/(ll-m);
          pmm=pmmp1;
          pmmp1=pll;
        }
        return pll;
     }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm5
movl %edx, %ebx
movl %esi, %r14d
testl %edx, %edx
js 0x4493
cmpl %r14d, %ebx
jg 0x4493
movapd 0x2c1b(%rip), %xmm0     # 0x70a0
andpd %xmm5, %xmm0
ucomisd 0x2b77(%rip), %xmm0     # 0x7008
jbe 0x44bf
movq 0x5b56(%rip), %rdi      # 0x9ff0
leaq 0x2ded(%rip), %rsi      # 0x728e
movapd %xmm5, -0x20(%rbp)
callq 0x21b0
leaq 0x2ec8(%rip), %rsi      # 0x737a
movq %rax, %rdi
callq 0x21b0
movapd -0x20(%rbp), %xmm5
testl %ebx, %ebx
jle 0x44ef
movsd 0x2b3d(%rip), %xmm6     # 0x7008
movapd %xmm6, %xmm1
subsd %xmm5, %xmm1
movapd %xmm5, %xmm0
addsd %xmm6, %xmm0
mulsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x452a
sqrtsd %xmm0, %xmm0
jmp 0x4541
movsd 0x2b11(%rip), %xmm1     # 0x7008
cmpl %ebx, %r14d
jne 0x4502
movapd %xmm1, %xmm0
jmp 0x4521
leal 0x1(,%rbx,2), %eax
cvtsi2sd %eax, %xmm2
mulsd %xmm5, %xmm2
mulsd %xmm1, %xmm2
leal 0x1(%rbx), %eax
cmpl %r14d, %eax
jne 0x4572
movapd %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movapd %xmm5, -0x20(%rbp)
callq 0x2160
movsd 0x2acc(%rip), %xmm6     # 0x7008
movapd -0x20(%rbp), %xmm5
movapd 0x2b67(%rip), %xmm2     # 0x70b0
movsd 0x2aef(%rip), %xmm3     # 0x7040
movl %ebx, %eax
movapd %xmm6, %xmm1
subl $0x1, %eax
jb 0x44f7
movapd %xmm6, %xmm4
xorpd %xmm2, %xmm4
mulsd %xmm0, %xmm4
mulsd %xmm4, %xmm1
addsd %xmm3, %xmm6
jmp 0x4557
leal 0x3(,%rbx,2), %eax
leal 0x1(,%rbx,2), %ecx
xorpd %xmm0, %xmm0
pushq $0x2
popq %rdx
leal (%rbx,%rdx), %esi
cmpl %r14d, %esi
jg 0x4521
cvtsi2sd %eax, %xmm0
cvtsi2sd %ecx, %xmm3
mulsd %xmm5, %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
subsd %xmm1, %xmm0
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
addl $0x2, %eax
incl %ecx
incl %edx
movapd %xmm2, %xmm1
movapd %xmm0, %xmm2
jmp 0x4587
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::YLM(int, int, double, double, double&, double&)
void CMolecularSystem::YLM(int l, int m, double theta, double phi, double &realYLM, double &imgYLM)
{
  double factor;
  double m_PLM;
  m_PLM = PLM(l,m,cos(theta));
  factor = ((2.0*double(l) + 1.0)*constants.factorials[l-m]) / (4.0*pi*constants.factorials[l+m]);
  realYLM = sqrt(factor) * m_PLM * cos(double(m)*phi);
  imgYLM  = sqrt(factor) * m_PLM * sin(double(m)*phi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movsd %xmm1, -0x38(%rbp)
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
callq 0x2370
movl %r12d, %esi
movl %r15d, %edx
callq 0x4460
movsd %xmm0, -0x30(%rbp)
cvtsi2sd %r12d, %xmm0
addsd %xmm0, %xmm0
addsd 0x298b(%rip), %xmm0     # 0x7008
leal (%r15,%r12), %eax
subl %r15d, %r12d
movslq %r12d, %rcx
cvtsi2sdl 0xb4e8c8(%r13,%rcx,4), %xmm1
mulsd %xmm0, %xmm1
cltq
cvtsi2sdl 0xb4e8c8(%r13,%rax,4), %xmm0
mulsd 0x299f(%rip), %xmm0     # 0x7048
divsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
movsd %xmm1, -0x40(%rbp)
ucomisd %xmm2, %xmm1
movsd %xmm0, -0x50(%rbp)
jae 0x46cf
movsd -0x40(%rbp), %xmm0
callq 0x2160
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
cvtsi2sd %r15d, %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x2370
mulsd -0x48(%rbp), %xmm0
movsd %xmm0, (%r14)
movsd -0x40(%rbp), %xmm0
ucomisd 0x294c(%rip), %xmm0     # 0x7050
movsd -0x50(%rbp), %xmm0
jae 0x4715
movsd -0x40(%rbp), %xmm0
callq 0x2160
movsd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x2090
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop