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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x42b1
movq %rsi, %r14
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movapd %xmm0, (%r15)
movq $0x0, 0x10(%r15)
xorl %r12d, %r12d
movl $0x3, %r13d
xorl %ebp, %ebp
leal -0x1(%rbp), %eax
testq %r12, %r12
cltq
cmoveq %r13, %rax
movq 0x18(%rsp), %rsi
leaq (%rax,%rax,2), %rax
movq 0x8(%r14,%rax,8), %rax
movq (%r14,%r12), %rdi
movq 0x8(%r14,%r12), %rcx
movsd 0x8(%rdi), %xmm0
movsd -0x8(%rax), %xmm1
movsd -0x10(%rax), %xmm2
movsd (%rdi), %xmm3
cmpeqpd %xmm2, %xmm3
cmpeqpd %xmm0, %xmm1
andpd %xmm3, %xmm1
movd %xmm1, %edx
andl $0x1, %edx
shll $0x4, %edx
addq %rdi, %rdx
movq %r15, %rdi
callq 0x4556
incq %rbp
addq $0x18, %r12
cmpq $0x4, %rbp
jne 0x422a
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
je 0x42c3
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x42fc
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x42fc
movq (%r14), %rax
movupd (%rax), %xmm0
leaq 0x30(%rsp), %rsi
movapd %xmm0, (%rsi)
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x43c6
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x42fc
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4310
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x432a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::remove()
void ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::remove(){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

	int old=nItems();

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

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

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

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

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

		delete cursor; //Destruimos el cursor auxiliar
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x348e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %eax, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x3408
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x3408
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x3479
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x3431
movq 0x10(%rbx), %rax
movq 0x60(%rax), %rcx
movq %rcx, 0x8(%rbx)
xorl %edx, %edx
movq %rdx, 0x58(%rcx)
movq %rdx, 0x60(%rax)
movq %rcx, 0x10(%rbx)
jmp 0x3479
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x345b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x10(%rbx), %rax
movq 0x60(%rax), %rcx
xorl %edx, %edx
movq %rdx, 0x58(%rcx)
movq %rdx, 0x60(%rax)
jmp 0x3479
movq 0x10(%rbx), %rdi
movq 0x58(%rdi), %rax
movq 0x60(%rdi), %rcx
movq %rcx, 0x60(%rax)
movq %rax, 0x58(%rcx)
movq %rcx, 0x10(%rbx)
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
incl %eax
cmpl %eax, %r14d
jne 0x34ad
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4c3c(%rip), %rdi      # 0x80d1
leaq 0x4c40(%rip), %rsi      # 0x80dc
leaq 0x522c(%rip), %rcx      # 0x86cf
movl $0x11b, %edx            # imm = 0x11B
callq 0x20e0
leaq 0x5261(%rip), %rdi      # 0x8715
leaq 0x4c21(%rip), %rsi      # 0x80dc
leaq 0x520d(%rip), %rcx      # 0x86cf
movl $0x13e, %edx            # imm = 0x13E
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::operator=(ed::ListaDoblementeEnlazadaOrdenadaEstudiantes&)
ed::ListaDoblementeEnlazadaOrdenadaEstudiantes &ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::operator=(ListaDoblementeEnlazadaOrdenadaEstudiantes &lista){
	int i;
	
	lista.gotoHead();
	
	while(!isEmpty()){
		remove();
	}
	
	for(i=0;i<lista.nItems();i++){
		insert(lista.getCurrentItem());
	}

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

	return * this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x38(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testb %al, %al
jne 0x34fc
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
jmp 0x34e5
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
testl %eax, %eax
jle 0x3532
xorl %r15d, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x68(%rcx)
incl %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
cmpl %eax, %r15d
jl 0x350c
movq 0x8(%rbx), %rax
cmpq 0x8(%r14), %rax
jne 0x354a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51d4(%rip), %rdi      # 0x8725
leaq 0x4b84(%rip), %rsi      # 0x80dc
leaq 0x51e1(%rip), %rcx      # 0x8740
movl $0x151, %edx            # imm = 0x151
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/./estudiante.hpp
// Function: ed::Estudiante::Estudiante(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float, float)
Estudiante(std::string nombre="",std::string apellidos="", float teoria=0.0, float  practica=0.0){
		this->setNombre(nombre);
		this->setApellidos(apellidos);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
movss %xmm0, -0x30(%rbp)
movss %xmm1, -0x2c(%rbp)
leaq 0x8443(%rip), %rax      # 0xbc60
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rbx, %rdi
callq 0x20b0
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x28(%rax)
movq (%r14), %rax
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq *0x30(%rax)
movq (%r14), %rax
leaq -0x2c(%rbp), %rsi
movq %r14, %rdi
callq *0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x28(%r14), %rdi
cmpq %r13, %rdi
je 0x3892
callq 0x2130
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x389f
callq 0x2130
movq %r15, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x75e2(%rip), %r14      # 0xbfd0
leaq 0x44d5(%rip), %rsi      # 0x8eca
movl $0x7, %edx
movq %r14, %rdi
callq 0x2180
leaq 0x44c9(%rip), %rsi      # 0x8ed2
movl $0x1a, %edx
movq %r14, %rdi
callq 0x2180
movq (%rbx), %rax
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2180
leaq 0x44b1(%rip), %rsi      # 0x8eed
movl $0x3, %edx
movq %rax, %rdi
callq 0x2180
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4a5b
callq 0x2130
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x7565(%rip), %rdi      # 0xbfd0
testb %al, %al
je 0x4a7d
leaq 0x42d3(%rip), %rsi      # 0x8d49
movl $0xc, %edx
jmp 0x4a89
leaq 0x446d(%rip), %rsi      # 0x8ef1
movl $0xf, %edx
callq 0x2180
movq 0x753b(%rip), %rdi      # 0xbfd0
leaq 0x358a(%rip), %rsi      # 0x8026
movl $0x4, %edx
callq 0x2180
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4ac6
callq 0x2130
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/funcionesAuxiliares.cpp
// Function: ed::cargarAsignatura(ed::Asignatura&)
void ed::cargarAsignatura(ed::Asignatura &asignatura){
  if(!asignatura.estaVacia()){ //La asignatura no esta vacia
	borrarAsignatura(asignatura); //Borramos los datos de la asignatura cargada para poder cargar otra
  }

  std::string nombreFichero;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x4af0
movq %rbx, %rdi
callq 0x4c72
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x74c5(%rip), %rdi      # 0xbfd0
leaq 0x43ef(%rip), %rsi      # 0x8f01
movl $0x7, %edx
callq 0x2180
movq 0x74ad(%rip), %rdi      # 0xbfd0
leaq 0x43df(%rip), %rsi      # 0x8f09
movl $0x20, %edx
callq 0x2180
movq 0x7495(%rip), %rdi      # 0xbfd0
leaq 0x43e8(%rip), %rsi      # 0x8f2a
movl $0x7, %edx
callq 0x2180
movq 0x747d(%rip), %rdi      # 0xbfd0
leaq 0x43d8(%rip), %rsi      # 0x8f32
movl $0x20, %edx
callq 0x2180
movq 0x7465(%rip), %r14      # 0xbfd0
leaq 0x34b4(%rip), %rsi      # 0x8026
movl $0x4, %edx
movq %r14, %rdi
callq 0x2180
movq 0x745a(%rip), %rdi      # 0xbfe0
leaq -0x38(%rbp), %rsi
callq 0x2190
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x3eda
testb %al, %al
je 0x4c40
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0x740f(%rip), %rdi      # 0xbfd0
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x437b(%rip), %rsi      # 0x8f53
movl $0x7, %edx
movq %rax, %rdi
callq 0x2180
leaq 0x436f(%rip), %rsi      # 0x8f5b
movl $0x20, %edx
movq %rbx, %rdi
callq 0x2180
leaq 0x3426(%rip), %rsi      # 0x8026
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x73a5(%rip), %rdi      # 0xbfe0
callq 0x2240
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4c4e
callq 0x2130
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4c6a
callq 0x2130
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/funcionesAuxiliares.cpp
// Function: ed::borrarAsignatura(ed::Asignatura&)
void ed::borrarAsignatura(ed::Asignatura &asignatura){
 asignatura.setCodigo(0);
 asignatura.setNombre("");

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

 std::cout << std::endl << ICYAN << "Asignatura borrada correctamente" << RESET << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
xorl %esi, %esi
callq *0x38(%rax)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x4090(%rip), %rdx      # 0x8d29
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x396a
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4cfd
callq 0x2130
jmp 0x4cfd
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq *0x50(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x4cc4
movq 0x72bf(%rip), %rbx      # 0xbfd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x4211(%rip), %rsi      # 0x8f53
movl $0x7, %edx
movq %rax, %rdi
callq 0x2180
leaq 0x43bc(%rip), %rsi      # 0x9112
movl $0x20, %edx
movq %rbx, %rdi
callq 0x2180
leaq 0x32bc(%rip), %rsi      # 0x8026
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4dba
callq 0x2130
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/./asignatura.hpp
// Function: ed::Asignatura::Asignatura(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Asignatura(int codigo = 0, std::string const &nombre =""){
		this->setCodigo(codigo);
	
		this->setNombre(nombre);

		/*
		El constructor de ListaDoblementeEnlazadaOrdenadaEstudiantes 
    		asigna los valores NULL a la cabeza y al cursor de _lista
	  	*/
  	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x437a(%rip), %rax      # 0xbd20
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r13
movq %r13, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
leaq 0x30(%rdi), %r15
leaq 0x41d4(%rip), %rax      # 0xbba0
addq $0x10, %rax
movq %rax, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq %r15, %rdi
callq 0x2bb0
testb %al, %al
je 0x7a0e
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
callq *0x38(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ac1(%rip), %rdi      # 0x94d6
leaq 0x1aca(%rip), %rsi      # 0x94e6
leaq 0x1af4(%rip), %rcx      # 0x9517
movl $0x74, %edx
callq 0x20e0
movq %rax, %r14
jmp 0x7a3d
movq %rax, %r14
movq %r15, %rdi
callq 0x7ab6
movq 0x10(%rbx), %rdi
cmpq %r13, %rdi
je 0x7a4b
callq 0x2130
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x3692
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c37(%rip), %rsi      # 0x80de
callq 0x20c0
testl %eax, %eax
je 0x3510
addq 0xb4e8c0(%rbx), %r14
leaq 0x7d42(%rip), %rsi      # 0xb200
movq %r14, %rdi
callq 0x2040
testl %eax, %eax
je 0x352c
movl $0x3230, %r14d          # imm = 0x3230
movq 0xb4e8c0(%rbx), %rdi
addq %r14, %rdi
leaq 0x7d3f(%rip), %rsi      # 0xb220
callq 0x2040
testl %eax, %eax
je 0x3538
addq 0xb4e8c0(%rbx), %r14
leaq 0x7d48(%rip), %rsi      # 0xb240
movq %r14, %rdi
callq 0x2040
movq %rbx, %rdi
testl %eax, %eax
je 0x3544
popq %rbx
popq %r14
popq %rbp
jmp 0x3b6c
movq 0x7ad9(%rip), %rdi      # 0xaff0
leaq 0x4bc7(%rip), %rsi      # 0x80e5
movl $0x5f, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x21f0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x354e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x371e
popq %rbx
popq %r14
popq %rbp
jmp 0x38fa
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb4e8c0(%rdi), %rax
movl 0x320c(%rax), %r14d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %r14
je 0x389a
cmpl $-0x1, 0x3208(%rax)
je 0x376f
movq 0x7899(%rip), %rdi      # 0xaff0
leaq 0x4a7e(%rip), %rsi      # 0x81dc
movl $0x3e, %edx
callq 0x21f0
movq 0xb4e8c0(%rbx), %rax
leal (%r14,%r14), %r15d
movl %r14d, %esi
imull %r14d, %esi
imull %r15d, %esi
movl %esi, 0x3208(%rax)
movq %rbx, %rdi
callq 0x3230
testl %r14d, %r14d
jle 0x38b2
cvtsi2sd %r14d, %xmm0
cvtsi2sd %r15d, %xmm1
movl %r14d, %eax
imull %r14d, %eax
xorl %ecx, %ecx
xorpd %xmm2, %xmm2
movsd 0x4854(%rip), %xmm3     # 0x8008
xorl %edx, %edx
movq 0xb4e8b8(%rbx), %rsi
movq 0xb4e8c0(%rbx), %rdi
movl %edx, %r8d
andl $0x1, %r8d
xorps %xmm9, %xmm9
cvtsi2sd %r8d, %xmm9
movsd 0x3218(%rdi), %xmm4
movsd 0x3220(%rdi), %xmm5
movapd %xmm4, %xmm6
divsd %xmm1, %xmm6
movapd %xmm5, %xmm7
divsd %xmm1, %xmm7
movsd 0x3228(%rdi), %xmm8
mulsd %xmm2, %xmm8
divsd %xmm1, %xmm8
mulsd %xmm9, %xmm7
mulsd %xmm9, %xmm6
movq %rcx, %rdi
xorpd %xmm9, %xmm9
xorl %r8d, %r8d
movapd %xmm5, %xmm10
mulsd %xmm9, %xmm10
divsd %xmm0, %xmm10
addsd %xmm7, %xmm10
xorl %r9d, %r9d
leal (%rdi,%r9), %r10d
xorps %xmm11, %xmm11
cvtsi2sd %r9d, %xmm11
mulsd %xmm4, %xmm11
divsd %xmm0, %xmm11
addsd %xmm6, %xmm11
movslq %r10d, %r10
imulq $0x870, %r10, %r10      # imm = 0x870
movsd %xmm11, 0x8(%rsi,%r10)
movsd %xmm10, 0x10(%rsi,%r10)
movsd %xmm8, 0x18(%rsi,%r10)
incq %r9
cmpq %r9, %r14
jne 0x3833
addsd %xmm3, %xmm9
incl %r8d
addq %r14, %rdi
cmpl %r14d, %r8d
jne 0x381c
addsd %xmm3, %xmm2
incl %edx
addq %rax, %rcx
cmpl %r15d, %edx
jne 0x37b6
jmp 0x38b2
movq 0x774f(%rip), %rdi      # 0xaff0
leaq 0x4973(%rip), %rsi      # 0x821b
movl $0x33, %edx
callq 0x21f0
movq 0xb4e8c0(%rbx), %rbx
cmpl $0x0, 0x3214(%rbx)
jns 0x38ef
movsd 0x3218(%rbx), %xmm0
divsd 0x3250(%rbx), %xmm0
callq 0x2300
cvttsd2si %xmm0, %eax
cmpl $0x6, %eax
movl $0x5, %ecx
cmovgel %eax, %ecx
addl $-0x2, %ecx
movl %ecx, 0x3214(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x47dd
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
movq $-0x1, %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
movl $0x68, %edx
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 0x4136
movl $0x1, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
callq 0x47d6
movq 0xb4e8c0(%r12), %r15
movl 0x3208(%r15), %ecx
movl 0x3214(%r15), %edx
movl %edx, %eax
imull %edx, %eax
imull %edx, %eax
testl %ecx, %ecx
jle 0x4991
movq 0x8(%r12), %rdx
xorl %esi, %esi
movl $0x1fca055, (%rdx,%rsi,4) # imm = 0x1FCA055
incq %rsi
movslq 0x3208(%r15), %rcx
cmpq %rcx, %rsi
jl 0x497b
testl %eax, %eax
jle 0x49b4
movq 0x10(%r12), %rcx
movl %eax, %eax
xorl %edx, %edx
movl $0x1fca055, (%rcx,%rdx,4) # imm = 0x1FCA055
incq %rdx
cmpq %rdx, %rax
jne 0x499e
movl 0x3208(%r15), %ecx
testl %ecx, %ecx
jle 0x4a0d
movq 0x8(%r12), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%r12), %r13
movl $0x554, %ebx            # imm = 0x554
addq 0xb4e8b8(%r12), %rbx
xorl %r14d, %r14d
movq %r12, %rdi
movl %r14d, %esi
callq 0x487c
movl %eax, (%rbx)
cltq
movl (%r13,%rax,4), %ecx
movq -0x30(%rbp), %rdx
movl %ecx, (%rdx,%r14,4)
movl %r14d, (%r13,%rax,4)
incq %r14
movslq 0x3208(%r15), %rax
addq $0x870, %rbx            # imm = 0x870
cmpq %rax, %r14
jl 0x49d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x18, %rsp
movq 0xb4e8c0(%rdi), %rax
movslq 0x3208(%rax), %r13
testq %r13, %r13
jle 0x4b61
movsd 0x3250(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0xb4e8b8(%rdi), %rax
xorl %ecx, %ecx
movabsq $-0x4010000000000000, %rdx # imm = 0xBFF0000000000000
movl $0x46, %esi
movl $0x1fca055, -0x78(%rax,%rsi,4) # imm = 0x1FCA055
movq %rdx, (%rax,%rsi,8)
incq %rsi
cmpq $0xaa, %rsi
jne 0x4a69
incq %rcx
addq $0x870, %rax            # imm = 0x870
cmpq %r13, %rcx
jne 0x4a64
testl %r13d, %r13d
jle 0x4b61
xorl %r14d, %r14d
movq %rdi, -0x30(%rbp)
imulq $0x870, %r14, %rcx      # imm = 0x870
movq 0xb4e8b8(%rdi), %rbx
movq %rcx, -0x38(%rbp)
addq %rcx, %rbx
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq %r12, %r14
je 0x4af1
movl %r14d, %esi
movl %r12d, %edx
callq 0x4b70
movsd -0x40(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4aed
movslq %r15d, %r15
movl %r12d, 0xa0(%rbx,%r15,4)
movsd %xmm0, 0x230(%rbx,%r15,8)
incl %r15d
movq -0x30(%rbp), %rdi
incq %r12
cmpl %r12d, %r13d
jne 0x4aba
movq 0xb4e8b8(%rdi), %rax
movq -0x38(%rbp), %rcx
movl %r15d, 0x550(%rax,%rcx)
movq 0x64bd(%rip), %rdi      # 0xafd0
movl %r14d, %esi
callq 0x2330
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x363a(%rip), %rsi      # 0x8167
callq 0x21f0
movq %r12, %rdi
movl %r15d, %esi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
leaq 0x382e(%rip), %rsi      # 0x837a
callq 0x21f0
movq -0x30(%rbp), %rdi
incq %r14
cmpq %r13, %r14
jne 0x4a9f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movapd %xmm0, %xmm5
movl %edx, %ebx
movl %esi, %r14d
testl %edx, %edx
js 0x4cf5
cmpl %ebx, %r14d
jl 0x4cf5
movapd 0x33b9(%rip), %xmm0     # 0x80a0
andpd %xmm5, %xmm0
ucomisd 0x3315(%rip), %xmm0     # 0x8008
jbe 0x4d2e
movq 0x62f4(%rip), %r15      # 0xaff0
leaq 0x358b(%rip), %rsi      # 0x828e
movl $0x21, %edx
movq %r15, %rdi
movapd %xmm5, -0x30(%rbp)
callq 0x21f0
leaq 0x365e(%rip), %rsi      # 0x837a
movl $0x1, %edx
movq %r15, %rdi
callq 0x21f0
movapd -0x30(%rbp), %xmm5
movsd 0x32d2(%rip), %xmm6     # 0x8008
testl %ebx, %ebx
jle 0x4da3
movapd %xmm6, %xmm1
subsd %xmm5, %xmm1
movapd %xmm5, %xmm0
addsd %xmm6, %xmm0
mulsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4d5e
sqrtsd %xmm0, %xmm0
jmp 0x4d75
movapd %xmm5, -0x30(%rbp)
callq 0x2150
movsd 0x3298(%rip), %xmm6     # 0x8008
movapd -0x30(%rbp), %xmm5
movapd 0x3333(%rip), %xmm1     # 0x80b0
movsd 0x32bb(%rip), %xmm2     # 0x8040
movl %ebx, %eax
movapd %xmm6, %xmm3
movapd %xmm3, %xmm4
xorpd %xmm1, %xmm4
mulsd %xmm0, %xmm4
mulsd %xmm4, %xmm6
addsd %xmm2, %xmm3
decl %eax
jne 0x4d8b
movl %r14d, %eax
subl %ebx, %eax
jne 0x4db3
movapd %xmm6, %xmm0
jmp 0x4e34
leal 0x1(,%rbx,2), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd %xmm5, %xmm1
mulsd %xmm6, %xmm1
leal 0x1(%rbx), %ecx
cmpl %r14d, %ecx
jne 0x4dd7
movapd %xmm1, %xmm0
jmp 0x4e34
leal 0x2(%rbx), %ecx
xorpd %xmm0, %xmm0
cmpl %r14d, %ecx
jg 0x4e34
movl %ebx, %ecx
addl %ebx, %ebx
leal 0x3(,%rcx,2), %ecx
movl $0x1, %edx
movapd %xmm1, %xmm0
leal (%rbx,%rdx), %esi
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
mulsd %xmm6, %xmm1
movapd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd %xmm5, %xmm0
mulsd %xmm2, %xmm0
subsd %xmm1, %xmm0
incl %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
addl $0x2, %ecx
movapd %xmm2, %xmm6
cmpl %edx, %eax
jne 0x4df7
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2380
movl %r12d, %esi
movl %r15d, %edx
callq 0x4cc0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
addsd %xmm0, %xmm0
addsd 0x3108(%rip), %xmm0     # 0x8008
leal (%r15,%r12), %eax
subl %r15d, %r12d
movslq %r12d, %rcx
xorps %xmm1, %xmm1
cvtsi2sdl 0xb4e8c8(%r13,%rcx,4), %xmm1
mulsd %xmm0, %xmm1
cltq
xorps %xmm0, %xmm0
cvtsi2sdl 0xb4e8c8(%r13,%rax,4), %xmm0
mulsd 0x3116(%rip), %xmm0     # 0x8048
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
movsd %xmm1, -0x40(%rbp)
ucomisd %xmm2, %xmm1
movsd %xmm0, -0x50(%rbp)
jae 0x4f5b
movsd -0x40(%rbp), %xmm0
callq 0x2150
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x2380
mulsd -0x48(%rbp), %xmm0
movsd %xmm0, (%r14)
movsd -0x40(%rbp), %xmm0
ucomisd 0x30bd(%rip), %xmm0     # 0x8050
movsd -0x50(%rbp), %xmm0
jae 0x4fa4
movsd -0x40(%rbp), %xmm0
callq 0x2150
movsd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x2080
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movl %esi, -0x30(%rbp)
movq %rdi, %r13
movq 0x10(%rbp), %rdx
xorl %eax, %eax
movq %r9, -0x40(%rbp)
movq %rax, (%r9)
movq %rdx, -0x48(%rbp)
movq %rax, (%rdx)
leaq -0x70(%rbp), %r12
leaq -0x68(%rbp), %rbx
leaq -0x60(%rbp), %r14
movl %ecx, %esi
movl %r8d, %edx
movq %r12, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0x5114
movsd (%r12), %xmm2
movsd %xmm2, -0x50(%rbp)
movsd (%rbx), %xmm1
movsd %xmm1, -0x58(%rbp)
movsd (%r14), %xmm0
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
sqrtsd %xmm1, %xmm1
divsd %xmm1, %xmm0
callq 0x2180
movsd %xmm0, -0x38(%rbp)
movsd -0x58(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
callq 0x2060
movaps %xmm0, %xmm1
testl %r15d, %r15d
js 0x50a4
movq %r13, %rdi
movl -0x30(%rbp), %esi
movl %r15d, %edx
movsd -0x38(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4eb2
movl %r15d, %edx
negl %edx
movq %r13, %rdi
movl -0x30(%rbp), %esi
movsd -0x38(%rbp), %xmm0
movq -0x40(%rbp), %r14
movq %r14, %rcx
movq -0x48(%rbp), %rbx
movq %rbx, %r8
callq 0x4eb2
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd 0x2f7c(%rip), %xmm0     # 0x8058
callq 0x2340
mulsd (%r14), %xmm0
movsd %xmm0, (%r14)
movsd 0x2f65(%rip), %xmm0     # 0x8058
movsd -0x30(%rbp), %xmm1
callq 0x2340
mulsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_distance(int, int, double&, double&, double&)
void CMolecularSystem::get_distance(int ti ,int tj ,double &diffx ,double &diffy,double &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;};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb4e8b8(%rdi), %rax
movslq %edx, %rdx
imulq $0x870, %rdx, %rdx      # imm = 0x870
movsd 0x8(%rax,%rdx), %xmm0
movslq %esi, %rsi
imulq $0x870, %rsi, %rsi      # imm = 0x870
subsd 0x8(%rax,%rsi), %xmm0
movsd %xmm0, (%rcx)
movsd 0x10(%rax,%rdx), %xmm0
subsd 0x10(%rax,%rsi), %xmm0
movsd %xmm0, (%r8)
movsd 0x18(%rax,%rdx), %xmm0
subsd 0x18(%rax,%rsi), %xmm0
movsd %xmm0, (%r9)
movsd (%rcx), %xmm0
movq 0xb4e8c0(%rdi), %rax
movsd 0x3218(%rax), %xmm1
movsd 0x2e98(%rip), %xmm2     # 0x8018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x519a
subsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
movsd 0x3218(%rax), %xmm1
movsd 0x2e96(%rip), %xmm2     # 0x8038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x51b4
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
movsd (%r8), %xmm0
movsd 0x3220(%rax), %xmm1
movsd 0x2e4f(%rip), %xmm2     # 0x8018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x51e4
subsd %xmm1, %xmm0
movsd %xmm0, (%r8)
movsd 0x3220(%rax), %xmm1
movsd 0x2e4c(%rip), %xmm2     # 0x8038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x51ff
addsd %xmm1, %xmm0
movsd %xmm0, (%r8)
movsd (%r9), %xmm0
movsd 0x3228(%rax), %xmm1
movsd 0x2e04(%rip), %xmm2     # 0x8018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x522f
subsd %xmm1, %xmm0
movsd %xmm0, (%r9)
movsd 0x3228(%rax), %xmm1
movsd 0x2e01(%rip), %xmm2     # 0x8038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x524a
addsd %xmm1, %xmm0
movsd %xmm0, (%r9)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::calculate_averageComplexQLM()
void CMolecularSystem::calculate_averageComplexQLM()
{
  int nop;
  nop = this->parameter->nop;
  double realNQ6[13],imgNQ6[13];
  double realNQ4[9],imgNQ4[9];

  for (int ti= 0;ti<nop;ti++)
  {
    for (int mi=0;mi<13;mi++)
    {
      realNQ6[mi] = this->molecules[ti].realQ6[mi];
      imgNQ6[mi]  = this->molecules[ti].imgQ6[mi];
      for (int ci = 0;ci<this->molecules[ti].n_neighbors;ci++)
      {
        realNQ6[mi] += this->molecules[this->molecules[ti].neighbors[ci]].realQ6[mi];
        imgNQ6[mi]  += this->molecules[this->molecules[ti].neighbors[ci]].imgQ6[mi];
      }
      realNQ6[mi] = realNQ6[mi]/double(this->molecules[ti].n_neighbors+1);
      imgNQ6[mi]  = imgNQ6[mi]/double(this->molecules[ti].n_neighbors+1);

      this->molecules[ti].arealQ6[mi] = realNQ6[mi];
      this->molecules[ti].aimgQ6[mi] = imgNQ6[mi];
    }

    for (int mi=0;mi<9;mi++)
    {
      realNQ4[mi] = this->molecules[ti].realQ4[mi];
      imgNQ4[mi]  = this->molecules[ti].imgQ4[mi];
      for (int ci = 0;ci<this->molecules[ti].n_neighbors;ci++)
      {
        realNQ4[mi] += this->molecules[this->molecules[ti].neighbors[ci]].realQ4[mi];
        imgNQ4[mi]  += this->molecules[this->molecules[ti].neighbors[ci]].imgQ4[mi];
      }
      realNQ4[mi] = realNQ4[mi]/double(this->molecules[ti].n_neighbors+1);
      imgNQ4[mi]  = imgNQ4[mi]/double(this->molecules[ti].n_neighbors+1);

      this->molecules[ti].arealQ4[mi] = realNQ4[mi];
      this->molecules[ti].aimgQ4[mi] = imgNQ4[mi];
    }

  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb4e8c0(%rdi), %rax
movslq 0x3208(%rax), %rax
testq %rax, %rax
jle 0x5576
movq 0xb4e8b8(%rdi), %rcx
leaq 0xa0(%rcx), %rdx
xorl %esi, %esi
imulq $0x870, %rsi, %rdi      # imm = 0x870
movl 0x550(%rcx,%rdi), %r8d
leal 0x1(%r8), %r9d
xorps %xmm0, %xmm0
cvtsi2sd %r9d, %xmm0
addq %rcx, %rdi
xorl %r9d, %r9d
movsd 0x5e8(%rdi,%r9,8), %xmm2
movsd 0x650(%rdi,%r9,8), %xmm1
testl %r8d, %r8d
jle 0x54d0
xorl %r10d, %r10d
movslq (%rdx,%r10,4), %r11
imulq $0x870, %r11, %r11      # imm = 0x870
addq %rcx, %r11
addsd 0x5e8(%r11,%r9,8), %xmm2
addsd 0x650(%r11,%r9,8), %xmm1
incq %r10
cmpq %r10, %r8
jne 0x54a6
divsd %xmm0, %xmm2
divsd %xmm0, %xmm1
movsd %xmm2, 0x748(%rdi,%r9,8)
movsd %xmm1, 0x7b0(%rdi,%r9,8)
incq %r9
cmpq $0xd, %r9
jne 0x548a
xorl %r9d, %r9d
movsd 0x558(%rdi,%r9,8), %xmm2
movsd 0x5a0(%rdi,%r9,8), %xmm1
testl %r8d, %r8d
jle 0x553e
xorl %r10d, %r10d
movslq (%rdx,%r10,4), %r11
imulq $0x870, %r11, %r11      # imm = 0x870
addq %rcx, %r11
addsd 0x558(%r11,%r9,8), %xmm2
addsd 0x5a0(%r11,%r9,8), %xmm1
incq %r10
cmpq %r10, %r8
jne 0x5514
divsd %xmm0, %xmm2
divsd %xmm0, %xmm1
movsd %xmm2, 0x6b8(%rdi,%r9,8)
movsd %xmm1, 0x700(%rdi,%r9,8)
incq %r9
cmpq $0x9, %r9
jne 0x54f8
incq %rsi
addq $0x870, %rdx            # imm = 0x870
cmpq %rax, %rsi
jne 0x5469
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::calculate_qFromComplexVector()
void CMolecularSystem::calculate_qFromComplexVector()
{
  int nop;
  nop = this->parameter->nop;
  double sumQ6,sumQ4;
  for (int ti= 0;ti<nop;ti++)
  {
    sumQ6 = 0.0;
    sumQ4 = 0.0;
    for (int mi = 0;mi < 13;mi++)
    {
      sumQ6 += this->molecules[ti].realQ6[mi]*this->molecules[ti].realQ6[mi] + this->molecules[ti].imgQ6[mi]*this->molecules[ti].imgQ6[mi];
      //if (ti == 0) {cout << ti << " " << mi << " " << this->molecules[ti].realQ6[mi]*this->molecules[ti].realQ6[mi] + this->molecules[ti].imgQ6[mi]*this->molecules[ti].imgQ6[mi] << "\n";}
    }
    sumQ6 = pow(((4.0*pi/13.0) * sumQ6),0.5);
    this->molecules[ti].Q6 = sumQ6;

    for (int mi = 0;mi < 9;mi++)
    {
	sumQ4 += this->molecules[ti].realQ4[mi]*this->molecules[ti].realQ4[mi] + this->molecules[ti].imgQ4[mi]*this->molecules[ti].imgQ4[mi];
    }
    sumQ4 = pow(((4.0*pi/9.0) * sumQ4),0.5);
    this->molecules[ti].Q4 = sumQ4;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xb4e8c0(%rdi), %rax
movslq 0x3208(%rax), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
jle 0x5681
movq %rdi, %rbx
movq 0xb4e8b8(%rdi), %rax
movl $0x650, %r15d           # imm = 0x650
movl $0x5a0, %r12d           # imm = 0x5A0
xorl %r13d, %r13d
addq %r15, %rax
xorpd %xmm0, %xmm0
movq $-0xd, %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x68(%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jne 0x55c8
mulsd 0x2a70(%rip), %xmm0     # 0x8060
movsd 0x2a20(%rip), %xmm1     # 0x8018
callq 0x2340
movq 0xb4e8b8(%rbx), %rax
imulq $0x870, %r13, %r14      # imm = 0x870
movsd %xmm0, 0x818(%rax,%r14)
addq %r12, %rax
xorpd %xmm0, %xmm0
movq $-0x9, %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x48(%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jne 0x5623
mulsd 0x2a1d(%rip), %xmm0     # 0x8068
movsd 0x29c5(%rip), %xmm1     # 0x8018
callq 0x2340
movq 0xb4e8b8(%rbx), %rax
movsd %xmm0, 0x820(%rax,%r14)
incq %r13
movl $0x870, %ecx            # imm = 0x870
addq %rcx, %r15
addq %rcx, %r12
cmpq -0x30(%rbp), %r13
jne 0x55ba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::calculate_averagedqFromComplexVector()
void CMolecularSystem::calculate_averagedqFromComplexVector()
{
  int nop;
  nop = this->parameter->nop;
  double sumAQ4,sumAQ6;

  for (int ti= 0;ti<nop;ti++)
  {
    sumAQ4 = 0.0;
    for (int hi=0;hi<9;hi++)
    {
      sumAQ4 += this->molecules[ti].arealQ4[hi]*this->molecules[ti].arealQ4[hi]+ this->molecules[ti].aimgQ4[hi]*this->molecules[ti].aimgQ4[hi];
    }
    sumAQ4  = sumAQ4 * 4.0*pi/9.0;
    sumAQ4  = pow(sumAQ4 ,0.5);

    sumAQ6 = 0.0;
    for (int hi=0;hi<13;hi++)
    {
      sumAQ6 += this->molecules[ti].arealQ6[hi]*this->molecules[ti].arealQ6[hi]+ this->molecules[ti].aimgQ6[hi]*this->molecules[ti].aimgQ6[hi];
    }
    sumAQ6  = sumAQ6 * 4.0*pi/13.0;
    sumAQ6  = pow(sumAQ6 ,0.5);

    this->molecules[ti].AQ4 = sumAQ4;
    this->molecules[ti].AQ6 = sumAQ6;
  }

}

// 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), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
jle 0x57c5
movq %rdi, %rbx
movq 0xb4e8b8(%rdi), %rax
movl $0x700, %r15d           # imm = 0x700
movl $0x7b0, %r12d           # imm = 0x7B0
xorl %r13d, %r13d
movl $0x870, %r14d           # imm = 0x870
addq %r15, %rax
xorpd %xmm0, %xmm0
movq $-0x9, %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x48(%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jne 0x56e9
mulsd 0x295f(%rip), %xmm0     # 0x8070
mulsd 0x295f(%rip), %xmm0     # 0x8078
divsd 0x295f(%rip), %xmm0     # 0x8080
movsd 0x28ef(%rip), %xmm1     # 0x8018
callq 0x2340
movsd %xmm0, -0x38(%rbp)
movq 0xb4e8b8(%rbx), %rax
addq %r12, %rax
xorpd %xmm0, %xmm0
movq $-0xd, %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x68(%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jne 0x5748
mulsd 0x2900(%rip), %xmm0     # 0x8070
mulsd 0x2900(%rip), %xmm0     # 0x8078
divsd 0x2908(%rip), %xmm0     # 0x8088
movsd 0x2890(%rip), %xmm1     # 0x8018
callq 0x2340
movq 0xb4e8b8(%rbx), %rax
imulq $0x870, %r13, %rcx      # imm = 0x870
movsd -0x38(%rbp), %xmm1
movsd %xmm1, 0x840(%rax,%rcx)
movsd %xmm0, 0x838(%rax,%rcx)
incq %r13
addq %r14, %r15
addq %r14, %r12
cmpq -0x30(%rbp), %r13
jne 0x56db
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::calculate_frenkelNumbers()
void CMolecularSystem::calculate_frenkelNumbers()
{
  int frenkelcons;
  double scalar;
  for (int ti= 0;ti<this->parameter->nop;ti++)
  {
    frenkelcons = 0;
    for (int c = 0;c<this->molecules[ti].n_neighbors;c++)
    {
      scalar = this->get_NumberFromBond(ti,this->molecules[ti].neighbors[c]);
      if (scalar > 0.5) frenkelcons += 1;
    }
    this->molecules[ti].frenkelnumber = frenkelcons;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xb4e8c0(%rdi), %rcx
cmpl $0x0, 0x3208(%rcx)
jle 0x5c22
movq %rdi, %rbx
movq 0xb4e8b8(%rdi), %rax
movl $0xa0, %r14d
xorl %r13d, %r13d
imulq $0x870, %r13, %rdx      # imm = 0x870
cmpl $0x0, 0x550(%rax,%rdx)
jle 0x5bfa
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %rdx, -0x30(%rbp)
addq %r14, %rax
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5a36
movq -0x30(%rbp), %rdx
movsd 0x2452(%rip), %xmm1     # 0x8018
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
addl %eax, %r15d
incq %r12
movq 0xb4e8b8(%rbx), %rax
movslq 0x550(%rax,%rdx), %rcx
cmpq %rcx, %r12
jl 0x5ba8
movq 0xb4e8c0(%rbx), %rcx
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
jmp 0x5bfe
xorpd %xmm0, %xmm0
movsd %xmm0, 0x858(%rax,%rdx)
incq %r13
movslq 0x3208(%rcx), %rdx
movl $0x870, %edi            # imm = 0x870
addq %rdi, %r14
cmpq %rdx, %r13
jl 0x5b8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop