LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
callq *(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x4114
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x411d
jmp 0x411f
jmp 0x413e
leaq 0x70d6(%rip), %rdi      # 0xb1fc
leaq 0x6fb7(%rip), %rsi      # 0xb0e4
movl $0x8c, %edx
leaq 0x72bf(%rip), %rcx      # 0xb3f8
callq 0x3140
movq -0x18(%rbp), %rdi
callq 0x4db0
movq %rax, %rdi
callq 0x4d90
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x4df0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %al
jne 0x4193
jmp 0x419c
movb $0x0, -0x1(%rbp)
jmp 0x4299
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x41b8
jmp 0x422e
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x38d0
testb $0x1, %al
jne 0x41dc
jmp 0x421f
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x38d0
testb $0x1, %al
jne 0x41f8
jmp 0x41fa
jmp 0x4219
leaq 0x7463(%rip), %rdi      # 0xb664
leaq 0x6edc(%rip), %rsi      # 0xb0e4
movl $0x9e, %edx
leaq 0x722c(%rip), %rcx      # 0xb440
callq 0x3140
movb $0x1, -0x1(%rbp)
jmp 0x4299
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x41a6
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x38d0
testb $0x1, %al
jne 0x4252
jmp 0x4295
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x38d0
testb $0x1, %al
jne 0x426e
jmp 0x4270
jmp 0x428f
leaq 0x73ed(%rip), %rdi      # 0xb664
leaq 0x6e66(%rip), %rsi      # 0xb0e4
movl $0xad, %edx
leaq 0x71b6(%rip), %rcx      # 0xb440
callq 0x3140
movb $0x1, -0x1(%rbp)
jmp 0x4299
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x4cd3
jmp 0x4cdf
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
jmp 0x4cc2
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x4d21
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x68(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4ce6
movq -0x20(%rbp), %rdi
callq 0x4d70
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4d70
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x4d45
jmp 0x4d64
leaq 0x69e1(%rip), %rdi      # 0xb72d
leaq 0x6391(%rip), %rsi      # 0xb0e4
movl $0x151, %edx            # imm = 0x151
leaq 0x69e9(%rip), %rcx      # 0xb748
callq 0x3140
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x52a0
movq -0x38(%rbp), %rdi
leaq 0xac80(%rip), %rax      # 0xfae8
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3220
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3220
jmp 0x4e8b
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0x48(%rbp)
jmp 0x4e9d
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x4eb0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, -0x50(%rbp)
jmp 0x4ec3
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0x4ed6
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movss %xmm0, -0x54(%rbp)
jmp 0x4eea
movq -0x38(%rbp), %rdi
movss -0x54(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movq (%rdi), %rax
movq 0x30(%rax), %rax
leaq -0x20(%rbp), %rsi
callq *%rax
jmp 0x4f07
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movss %xmm0, -0x58(%rbp)
jmp 0x4f1b
movq -0x38(%rbp), %rdi
movss -0x58(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movq (%rdi), %rax
movq 0x38(%rax), %rax
leaq -0x24(%rbp), %rsi
callq *%rax
jmp 0x4f38
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x4f65
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3120
jmp 0x4f63
jmp 0x4f65
movq -0x40(%rbp), %rdi
callq 0x3120
jmp 0x4f70
jmp 0x4f72
movq -0x18(%rbp), %rdi
callq 0x32b0
movq %rax, %rdi
callq 0x5040
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x52a0
movq -0x40(%rbp), %rdi
leaq 0xa6ea(%rip), %rax      # 0xfae8
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3220
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3220
jmp 0x5421
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x5434
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0x5447
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
leaq -0x1c(%rbp), %rsi
callq *%rax
jmp 0x545a
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
leaq -0x20(%rbp), %rsi
callq *%rax
jmp 0x546d
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x549a
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3120
jmp 0x5498
jmp 0x549a
movq -0x48(%rbp), %rdi
callq 0x3120
jmp 0x54a5
jmp 0x54a7
movq -0x28(%rbp), %rdi
callq 0x32b0
movq %rax, %rdi
callq 0x5040
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jg 0x56be
jmp 0x56dd
leaq 0x6390(%rip), %rdi      # 0xba55
leaq 0x6314(%rip), %rsi      # 0xb9e0
movl $0x1b, %edx
leaq 0x639c(%rip), %rcx      # 0xba74
callq 0x3140
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x3f20
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5711
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x40e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x56f1
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x3cd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x577e
jmp 0x57ed
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x3cd0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3b40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x57ba
jmp 0x57ed
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x3cd0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3b40
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x57f6
jmp 0x57f8
jmp 0x5817
leaq 0x62b6(%rip), %rdi      # 0xbab5
leaq 0x61da(%rip), %rsi      # 0xb9e0
movl $0x2c, %edx
leaq 0x6348(%rip), %rcx      # 0xbb5a
callq 0x3140
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x42b0
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x3cd0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x3b40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x5864
jmp 0x5897
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x3cd0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x3b40
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x58a0
jmp 0x58a2
jmp 0x58c1
leaq 0x6241(%rip), %rdi      # 0xbaea
leaq 0x6130(%rip), %rsi      # 0xb9e0
movl $0x33, %edx
leaq 0x629e(%rip), %rcx      # 0xbb5a
callq 0x3140
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x5b50
jmp 0x5b52
jmp 0x5b71
leaq 0x603d(%rip), %rdi      # 0xbb96
leaq 0x5e80(%rip), %rsi      # 0xb9e0
movl $0x54, %edx
leaq 0x60fa(%rip), %rcx      # 0xbc66
callq 0x3140
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x5b90
movb $0x0, -0x1(%rbp)
jmp 0x5c16
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x30(%rbp), %rdi
movl %eax, -0x24(%rbp)
addq $0x30, %rdi
callq 0x4a80
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x5be8
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movl -0x38(%rbp), %eax
addl $0x1, %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5bf1
jmp 0x5bf3
jmp 0x5c12
leaq 0x60c4(%rip), %rdi      # 0xbcbe
leaq 0x5ddf(%rip), %rsi      # 0xb9e0
movl $0x62, %edx
leaq 0x6059(%rip), %rcx      # 0xbc66
callq 0x3140
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/./asignatura.hpp
// Function: ed::Asignatura::estaVacia() const
inline bool estaVacia() const{
		if(_lista.isEmpty()){ //La lista esta vacia
			return true;
		}

		else{ //La lista no esta vacia
			return false;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x3c40
testb $0x1, %al
jne 0x645f
jmp 0x6465
movb $0x1, -0x1(%rbp)
jmp 0x6469
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq 0x960d(%rip), %rdi      # 0xffd0
leaq 0x5650(%rip), %rsi      # 0xc01a
callq 0x31a0
movq %rax, %rdi
leaq 0x5649(%rip), %rsi      # 0xc022
callq 0x31a0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq *%rax
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x3180
movq %rax, -0x40(%rbp)
jmp 0x6a0a
movq -0x40(%rbp), %rdi
leaq 0x5628(%rip), %rsi      # 0xc03d
callq 0x31a0
jmp 0x6a1c
leaq -0x28(%rbp), %rdi
callq 0x3120
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x6a76
movq 0x9590(%rip), %rdi      # 0xffd0
leaq 0x5452(%rip), %rsi      # 0xbe99
callq 0x31a0
movq %rax, %rdi
leaq 0x45d8(%rip), %rsi      # 0xb02e
callq 0x31a0
jmp 0x6a98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3120
jmp 0x6a74
jmp 0x6a9e
movq 0x9553(%rip), %rdi      # 0xffd0
leaq 0x55bd(%rip), %rsi      # 0xc041
callq 0x31a0
movq %rax, %rdi
leaq 0x459b(%rip), %rsi      # 0xb02e
callq 0x31a0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x32b0
movq %rax, %rdi
callq 0x5040
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x6ad6
movq -0x8(%rbp), %rdi
callq 0x6c40
leaq -0x28(%rbp), %rdi
callq 0x3220
movq 0x94ea(%rip), %rdi      # 0xffd0
leaq 0x5564(%rip), %rsi      # 0xc051
callq 0x31a0
movq %rax, -0x40(%rbp)
jmp 0x6af8
movq -0x40(%rbp), %rdi
leaq 0x5556(%rip), %rsi      # 0xc059
callq 0x31a0
movq %rax, -0x48(%rbp)
jmp 0x6b0e
movq -0x48(%rbp), %rdi
leaq 0x5561(%rip), %rsi      # 0xc07a
callq 0x31a0
movq %rax, -0x50(%rbp)
jmp 0x6b24
movq -0x50(%rbp), %rdi
leaq 0x5553(%rip), %rsi      # 0xc082
callq 0x31a0
movq %rax, -0x58(%rbp)
jmp 0x6b3a
movq -0x58(%rbp), %rdi
leaq 0x44e9(%rip), %rsi      # 0xb02e
callq 0x31a0
jmp 0x6b4c
movq 0x948d(%rip), %rdi      # 0xffe0
leaq -0x28(%rbp), %rsi
callq 0x31f0
jmp 0x6b5e
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5c30
movb %al, -0x59(%rbp)
jmp 0x6b70
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x6b7c
jmp 0x6c10
movq 0x944d(%rip), %rdi      # 0xffd0
movq 0x9436(%rip), %rsi      # 0xffc0
callq 0x31c0
movq %rax, -0x68(%rbp)
jmp 0x6b95
movq -0x68(%rbp), %rdi
leaq 0x5503(%rip), %rsi      # 0xc0a3
callq 0x31a0
movq %rax, -0x70(%rbp)
jmp 0x6bab
movq -0x70(%rbp), %rdi
leaq 0x54f5(%rip), %rsi      # 0xc0ab
callq 0x31a0
movq %rax, -0x78(%rbp)
jmp 0x6bc1
movq -0x78(%rbp), %rdi
leaq 0x4462(%rip), %rsi      # 0xb02e
callq 0x31a0
movq %rax, -0x80(%rbp)
jmp 0x6bd7
movq -0x80(%rbp), %rdi
movq 0x93de(%rip), %rsi      # 0xffc0
callq 0x31c0
jmp 0x6be9
movq 0x93f0(%rip), %rdi      # 0xffe0
callq 0x32d0
jmp 0x6bf7
jmp 0x6c10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3120
jmp 0x6c22
leaq -0x28(%rbp), %rdi
callq 0x3120
addq $0x80, %rsp
popq %rbp
retq
jmp 0x6c24
movq -0x30(%rbp), %rdi
callq 0x32b0
movq %rax, %rdi
callq 0x5040
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
xorl %esi, %esi
callq *%rax
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x32c0
movq -0x48(%rbp), %rdx
leaq 0x51fe(%rip), %rsi      # 0xbe79
leaq -0x28(%rbp), %rdi
callq 0x3210
jmp 0x6c86
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
leaq -0x28(%rbp), %rsi
callq *%rax
jmp 0x6c99
leaq -0x28(%rbp), %rdi
callq 0x3120
jmp 0x6ca4
leaq -0x29(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x6cbf
jmp 0x6d39
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x30(%rax)
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x30(%rax)
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x6cad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6d2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3120
jmp 0x6d2c
jmp 0x6d2e
leaq -0x29(%rbp), %rdi
callq 0x31d0
jmp 0x6d8e
movq 0x9290(%rip), %rdi      # 0xffd0
movq 0x9279(%rip), %rsi      # 0xffc0
callq 0x31c0
movq %rax, %rdi
leaq 0x534d(%rip), %rsi      # 0xc0a3
callq 0x31a0
movq %rax, %rdi
leaq 0x54fd(%rip), %rsi      # 0xc262
callq 0x31a0
movq %rax, %rdi
leaq 0x42ba(%rip), %rsi      # 0xb02e
callq 0x31a0
movq %rax, %rdi
movq 0x923d(%rip), %rsi      # 0xffc0
callq 0x31c0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x32b0
movq %rax, %rdi
callq 0x5040
nop
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/./listaDoblementeEnlazadaOrdenadaEstudiantes.hpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::ListaDoblementeEnlazadaOrdenadaEstudiantes()
inline ListaDoblementeEnlazadaOrdenadaEstudiantes()
      {
				this->_head = NULL;
				this->_current = NULL;
			
				#ifndef NDEBUG
				// Se comprueba la postcondición
					assert(this->isEmpty());
				#endif //NDEBUG		
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xa0e0
movq -0x10(%rbp), %rdi
leaq 0x5a04(%rip), %rax      # 0xfa28
addq $0x10, %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %al
jne 0xa046
jmp 0xa048
jmp 0xa067
leaq 0x25d7(%rip), %rdi      # 0xc626
leaq 0x17a8(%rip), %rsi      # 0xb7fe
movl $0x74, %edx
leaq 0x25d4(%rip), %rcx      # 0xc636
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0xad7d(%rip), %rax      # 0xed18
movq %rax, (%rdi)
callq 0x4120
movl $0x3258, %edi           # imm = 0x3258
callq 0x3220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0xb1c0
jmp 0x3fbe
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0xb4e8c0(%rax)
movq 0xb4e8c0(%rax), %rcx
movl $0xffffffff, 0x3208(%rcx) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0x18(%rbp)
cmpl $0x3e8, -0x18(%rbp)     # imm = 0x3E8
jge 0x4088
movq -0x30(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl $0x0, 0x24(%rax,%rcx,4)
movslq -0x18(%rbp), %rcx
movl $0x0, 0xfc4(%rax,%rcx,4)
movslq -0x18(%rbp), %rcx
movl $0x0, 0x1f64(%rax,%rcx,4)
movslq -0x18(%rbp), %rcx
movl $0x0, 0x2f04(%rax,%rcx,4)
movl $0x0, 0x7a50a4(%rax)
movl $0x0, 0x7a50a8(%rax)
movl $0x0, 0x7a50ac(%rax)
movl $0x0, 0x7a50b0(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3fec
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x3258, %esi           # imm = 0x3258
callq 0x3230
jmp 0x4115
movl $0x0, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
jge 0x4106
movl $0x0, -0x20(%rbp)
cmpl $0x3e8, -0x20(%rbp)     # imm = 0x3E8
jge 0x40f9
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x3ea4, %rcx           # imm = 0x3EA4
movslq -0x1c(%rbp), %rdx
imulq $0xfa0, %rdx, %rdx      # imm = 0xFA0
addq %rdx, %rcx
movslq -0x20(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
addq $0x3d47a4, %rax         # imm = 0x3D47A4
movslq -0x1c(%rbp), %rcx
imulq $0xfa0, %rcx, %rcx      # imm = 0xFA0
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x409f
jmp 0x40fb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x408f
movq -0x30(%rbp), %rdi
callq 0x47e0
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x3430
nop
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xc8, -0xc(%rbp)
jge 0x48c6
movl $0x0, -0x10(%rbp)
cmpl $0x258, -0x10(%rbp)     # imm = 0x258
jge 0x48b6
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x7a50b8, %rcx         # imm = 0x7A50B8
movslq -0xc(%rbp), %rdx
imulq $0x12c0, %rdx, %rdx     # imm = 0x12C0
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq %rax, %rcx
addq $0x88f6b8, %rcx         # imm = 0x88F6B8
movslq -0xc(%rbp), %rdx
imulq $0x12c0, %rdx, %rdx     # imm = 0x12C0
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq %rax, %rcx
addq $0x979cb8, %rcx         # imm = 0x979CB8
movslq -0xc(%rbp), %rdx
imulq $0x12c0, %rdx, %rdx     # imm = 0x12C0
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
addq $0xa642b8, %rax         # imm = 0xA642B8
movslq -0xc(%rbp), %rcx
imulq $0x12c0, %rcx, %rcx     # imm = 0x12C0
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x480b
jmp 0x48b8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x47f7
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xa41d(%rip), %rcx      # 0xed08
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb4e8c0(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x490d
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0xb4e8b8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x498c
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
imulq $0x870, %rax, %rdx      # imm = 0x870
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x28(%rbp)
je 0x4974
movq -0x28(%rbp), %rdi
addq $-0x870, %rdi           # imm = 0xF790
movq %rdi, -0x40(%rbp)
callq 0xb0e0
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x28(%rbp)
jne 0x494f
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
imulq $0x870, %rax, %rsi      # imm = 0x870
addq $0x8, %rsi
callq 0x3480
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x49a7
movq -0x48(%rbp), %rdi
callq 0x3300
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x49c2
movq -0x50(%rbp), %rdi
callq 0x3300
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0xb4e8c0(%rax), %rax
cmpl $0x0, 0x3208(%rax)
jge 0x4b87
movl $0x1, %edi
callq 0x3140
movq %rax, %rdi
leaq 0xa1d0(%rip), %rsi      # 0xed38
xorl %eax, %eax
movl %eax, %edx
callq 0x3400
jmp 0x4cb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x4c89
movq -0x28(%rbp), %rax
movq 0xb4e8c0(%rax), %rax
movslq 0x3208(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x870, %ecx            # imm = 0x870
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
movq $-0x1, %rax
cmovbq %rax, %rdi
testb %cl, %cl
cmovneq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3030
movq %rax, -0x30(%rbp)
jmp 0x4bcf
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
cmpq $0x0, %rax
je 0x4c2b
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
imulq $0x870, %rcx, %rdx      # imm = 0x870
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb0b0
jmp 0x4c14
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
addq $0x870, %rax            # imm = 0x870
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x4c05
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0xb4e8b8(%rax)
jmp 0x4cad
movq -0x48(%rbp), %rcx
movq %rax, %rsi
movq -0x60(%rbp), %rax
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq %rax, %rcx
movq %rax, -0x68(%rbp)
je 0x4c7c
movq -0x68(%rbp), %rdi
addq $-0x870, %rdi           # imm = 0xF790
movq %rdi, -0x70(%rbp)
callq 0xb0e0
movq -0x48(%rbp), %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0x4c57
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x3480
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4caf
movq -0x10(%rbp), %rdi
callq 0x3110
movq %rax, -0x20(%rbp)
callq 0x33d0
addq $0x70, %rsp
popq %rbp
retq
jmp 0x4ca7
movq -0x10(%rbp), %rdi
callq 0x3430
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0xb4e8c0(%rax), %rdi
addq $0x3230, %rdi           # imm = 0x3230
leaq 0x7465(%rip), %rsi      # 0xc1ee
callq 0x3100
cmpl $0x0, %eax
jne 0x4dab
movq 0xa256(%rip), %rdi      # 0xeff0
leaq 0x7454(%rip), %rsi      # 0xc1f5
callq 0x3200
jmp 0x4e44
movq -0x10(%rbp), %rax
movq 0xb4e8c0(%rax), %rdi
addq $0x3230, %rdi           # imm = 0x3230
leaq 0xa4bc(%rip), %rsi      # 0xf280
callq 0x3040
cmpl $0x0, %eax
jne 0x4dd9
movq -0x10(%rbp), %rdi
callq 0x4e50
jmp 0x4e42
movq -0x10(%rbp), %rax
movq 0xb4e8c0(%rax), %rdi
addq $0x3230, %rdi           # imm = 0x3230
leaq 0xa4ae(%rip), %rsi      # 0xf2a0
callq 0x3040
cmpl $0x0, %eax
jne 0x4e07
movq -0x10(%rbp), %rdi
callq 0x5080
jmp 0x4e40
movq -0x10(%rbp), %rax
movq 0xb4e8c0(%rax), %rdi
addq $0x3230, %rdi           # imm = 0x3230
leaq 0xa4a0(%rip), %rsi      # 0xf2c0
callq 0x3040
cmpl $0x0, %eax
jne 0x4e35
movq -0x10(%rbp), %rdi
callq 0x52d0
jmp 0x4e3e
movq -0x10(%rbp), %rdi
callq 0x5660
jmp 0x4e40
jmp 0x4e42
jmp 0x4e44
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::setNumberOfCells()
void CMolecularSystem::setNumberOfCells()
{
  if (this->parameter->noc < 0.0)
    {
      this->parameter->noc = int(floor((this->parameter->boxx / this->parameter->neighbordistance)))-2;
      if (this->parameter->noc < 3)
      {
        this->parameter->noc = 3;
      }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0xb4e8c0(%rax), %rax
cvtsi2sdl 0x3214(%rax), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5b82
movq -0x10(%rbp), %rax
movq 0xb4e8c0(%rax), %rcx
movsd 0x3218(%rcx), %xmm0
movq 0xb4e8c0(%rax), %rax
divsd 0x3250(%rax), %xmm0
callq 0x33e0
movq -0x10(%rbp), %rax
cvttsd2si %xmm0, %edx
subl $0x2, %edx
movq 0xb4e8c0(%rax), %rcx
movl %edx, 0x3214(%rcx)
movq 0xb4e8c0(%rax), %rax
cmpl $0x3, 0x3214(%rax)
jge 0x5b80
movq -0x10(%rbp), %rax
movq 0xb4e8c0(%rax), %rax
movl $0x3, 0x3214(%rax)
jmp 0x5b82
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::convertIndex(int, int&, int&, int&)
void CMolecularSystem::convertIndex(int index,int &idx, int &idy, int &idz)
{
  int noc;
  noc = this->parameter->noc;
  idx = index%noc;
  idy = (index/noc)%noc;
  idz = index/(noc*noc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0xb4e8c0(%rax), %rax
movl 0x3214(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
cltd
idivl -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl %edx, (%rax)
movl -0xc(%rbp), %eax
cltd
idivl -0x2c(%rbp)
cltd
idivl -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl %edx, (%rax)
movl -0xc(%rbp), %eax
movl -0x2c(%rbp), %ecx
imull -0x2c(%rbp), %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, 0x20(%rax)
jne 0x631b
movq -0x18(%rbp), %rax
movq 0xb4e8c0(%rax), %rcx
movl 0x3214(%rcx), %ecx
movl %ecx, -0xc(%rbp)
movq 0xb4e8c0(%rax), %rax
movslq 0x3208(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0xc(%rbp), %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0xc(%rbp), %eax
cltq
movl $0x68, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq -0x18(%rbp), %rdi
movq %rax, 0x18(%rdi)
callq 0x5d40
movq -0x18(%rbp), %rax
movl $0x1, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_cellByIndex(int)
int CMolecularSystem::get_cellByIndex(int i)
{
  int cell,noc;
  double boxx,boxy,boxz;
  double x,y,z;
  boxx = this->parameter->boxx;
  boxy = this->parameter->boxy;
  boxz = this->parameter->boxz;
  noc = this->parameter->noc;

  x = this->molecules[i].posx;
  y = this->molecules[i].posy;
  z = this->molecules[i].posz;
  //cout << x << " " << y << " " << z << "\n";
  cell =  int (floor((x / boxx) * noc) +
               floor((y / boxy) * noc) * noc +
               floor((z / boxz) * noc) * noc * noc);
  return cell;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0xb4e8c0(%rax), %rcx
movsd 0x3218(%rcx), %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0xb4e8c0(%rax), %rcx
movsd 0x3220(%rcx), %xmm0
movsd %xmm0, -0x28(%rbp)
movq 0xb4e8c0(%rax), %rcx
movsd 0x3228(%rcx), %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0xb4e8c0(%rax), %rcx
movl 0x3214(%rcx), %ecx
movl %ecx, -0x14(%rbp)
movq 0xb4e8b8(%rax), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x870, %rdx, %rdx      # imm = 0x870
addq %rdx, %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, -0x38(%rbp)
movq 0xb4e8b8(%rax), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x870, %rdx, %rdx      # imm = 0x870
addq %rdx, %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0xb4e8b8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x870, %rcx, %rcx      # imm = 0x870
addq %rcx, %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x33e0
movsd %xmm0, -0x58(%rbp)
movsd -0x40(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x33e0
movsd -0x58(%rbp), %xmm1
cvtsi2sdl -0x14(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x33e0
movsd -0x50(%rbp), %xmm1
cvtsi2sdl -0x14(%rbp), %xmm2
mulsd %xmm2, %xmm0
cvtsi2sdl -0x14(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x6230
movq -0x28(%rbp), %rax
movq 0xb4e8c0(%rax), %rax
movl 0x3214(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
imull -0x14(%rbp), %eax
imull -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
movq 0xb4e8c0(%rcx), %rcx
cmpl 0x3208(%rcx), %eax
jge 0x64f6
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movl $0x1fca055, (%rax,%rcx,4) # imm = 0x1FCA055
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x64c2
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x6523
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl $0x1fca055, (%rax,%rcx,4) # imm = 0x1FCA055
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x64fd
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
movq 0xb4e8c0(%rcx), %rcx
cmpl 0x3208(%rcx), %eax
jge 0x65a2
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x6330
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl -0xc(%rbp), %edx
movq 0xb4e8b8(%rax), %rcx
movslq -0x20(%rbp), %rsi
imulq $0x870, %rsi, %rsi      # imm = 0x870
addq %rsi, %rcx
movl %edx, 0x554(%rcx)
movq 0x10(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x8(%rax), %rcx
movslq -0x20(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movl -0x20(%rbp), %edx
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x652a
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x5c(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x3460
movl -0x60(%rbp), %esi
movl -0x5c(%rbp), %edx
movq -0x58(%rbp), %rdi
callq 0x6aa0
movq -0x58(%rbp), %rax
movsd %xmm0, -0x40(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
addsd %xmm0, %xmm0
movsd 0x52bd(%rip), %xmm1     # 0xc078
addsd %xmm1, %xmm0
movl -0xc(%rbp), %ecx
subl -0x10(%rbp), %ecx
movslq %ecx, %rcx
cvtsi2sdl 0xb4e8c8(%rax,%rcx,4), %xmm1
mulsd %xmm1, %xmm0
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
cvtsi2sdl 0xb4e8c8(%rax,%rcx,4), %xmm2
movsd 0x5381(%rip), %xmm1     # 0xc170
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x31a0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
callq 0x3460
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
callq 0x31a0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
callq 0x30b0
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
// File: WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::QLM(int, int, int, int, double&, double&)
void CMolecularSystem::QLM(int l,int m,int ti,int tj,double &realYLM, double &imgYLM )
{
  double diffx, diffy, diffz;
  double r,phi,theta;
  realYLM = 0.0;
  imgYLM = 0.0;
  this->get_distance(ti,tj,diffx,diffy,diffz);
  this->convert_SphericalCoordinates(diffx, diffy, diffz, r, phi, theta);
  if (m < 0) {
    YLM(l, abs(m), theta, phi, realYLM, imgYLM);
    realYLM = pow(-1.0,m)*realYLM;
    imgYLM = pow(-1.0,m)*imgYLM;
  }
    else
  {
    YLM(l, m, theta, phi, realYLM, imgYLM);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq 0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
callq 0x6f90
movq -0x58(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x6cb0
cmpl $0x0, -0x10(%rbp)
jge 0x6f5a
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl %edx, %eax
negl %eax
cmovnsl %eax, %edx
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movq -0x20(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x6d50
movl -0x10(%rbp), %edi
movsd 0x5245(%rip), %xmm0     # 0xc168
callq 0xadc0
movq -0x20(%rbp), %rax
mulsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl -0x10(%rbp), %edi
movsd 0x5225(%rip), %xmm0     # 0xc168
callq 0xadc0
movq 0x10(%rbp), %rax
mulsd (%rax), %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x6f7b
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movq -0x20(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x6d50
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)