LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(ed::Estudiante const&)
ed::Estudiante const &ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(ed::Estudiante const & item){
	//Precondición
	#ifndef NDEBUG
		assert(exists(item));
	#endif

	if(getItem()==item){ //El nodo raíz contiene el ítem que buscamos
		return getItem();
	}

	else{
		if(item<getItem()){ //El ítem está a la izquierda
			return getLeftTree()->getEstudiante(item); //Buscamos el ítem en el subárbol hijo izquierdo
		}

		else{ //El ítem está a la derecha
			return getRightTree()->getEstudiante(item); //Buscamos el ítem en el subárbol hijo derecho
		}
	}
}

// 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 -0x18(%rbp), %rsi
callq 0x2e80
testb $0x1, %al
jne 0x2f87
jmp 0x2f89
jmp 0x2fa8
leaq 0x7395(%rip), %rdi      # 0xa325
leaq 0x71a6(%rip), %rsi      # 0xa13d
movl $0x5f, %edx
leaq 0x71ff(%rip), %rcx      # 0xa1a2
callq 0x2140
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2960
testb $0x1, %al
jne 0x2fc4
jmp 0x2fd4
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x8(%rbp)
jmp 0x302c
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 0x29e0
testb $0x1, %al
jne 0x2ff8
jmp 0x3013
movq -0x20(%rbp), %rdi
callq 0x3f40
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2f60
movq %rax, -0x8(%rbp)
jmp 0x302c
movq -0x20(%rbp), %rdi
callq 0x3f90
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2f60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(int)
ed::Estudiante const &ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(int indice){
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty() and indice<=nItems());
	#endif

	if(hasLeftTree()){ //El nodo raíz tiene un subárbol hijo izquierdo
		if(indice==getLeftTree()->nItems()){ //El ítem está en el nodo raíz
			return getItem();
		}

		else if(indice<getLeftTree()->nItems()){ //El ítem está a la izquierda
			return getLeftTree()->getEstudiante(indice); //Buscamos el ítem en el subárbol hijo izquierdo
		}

		else{ //El ítem está a la derecha
			return getRightTree()->getEstudiante(indice-(getLeftTree()->nItems()+1)); //Buscamos el ítem en el subárbol hijo derecho
		}
	}

	else{ //El nodo raíz no tiene un subárbol hijo izquierdo
		if(indice==0){ //El ítem está en el nodo raíz
			return getItem();
		}

		else{ //El ítem está a la derecha
			return getRightTree()->getEstudiante(indice-1); //Buscamos el ítem en el subárbol hijo derecho
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x40a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x15(%rbp)
jne 0x3084
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x2de0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
setle %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x308d
jmp 0x308f
jmp 0x30ae
leaq 0x7170(%rip), %rdi      # 0xa206
leaq 0x70a0(%rip), %rsi      # 0xa13d
movl $0x74, %edx
leaq 0x717d(%rip), %rcx      # 0xa226
callq 0x2140
movq -0x20(%rbp), %rdi
callq 0x3f10
testb $0x1, %al
jne 0x30c0
jmp 0x3168
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
callq 0x3f40
movq %rax, %rdi
callq 0x2de0
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jne 0x30f3
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x8(%rbp)
jmp 0x3199
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x3f40
movq %rax, %rdi
callq 0x2de0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x312d
movq -0x20(%rbp), %rdi
callq 0x3f40
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x3040
movq %rax, -0x8(%rbp)
jmp 0x3199
movq -0x20(%rbp), %rdi
callq 0x3f90
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x3f40
movq %rax, %rdi
callq 0x2de0
movl -0x3c(%rbp), %esi
movq -0x38(%rbp), %rdi
addl $0x1, %eax
subl %eax, %esi
callq 0x3040
movq %rax, -0x8(%rbp)
jmp 0x3199
cmpl $0x0, -0x14(%rbp)
jne 0x317e
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x8(%rbp)
jmp 0x3199
movq -0x20(%rbp), %rdi
callq 0x3f90
movq %rax, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x3040
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::getMinor() const
ed::Estudiante const &ed::NodoEnlazadoArbolBinarioEstudiante::getMinor() const{
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty());
	#endif

	if(hasLeftTree()){ //El nodo raíz tiene un subárbol hijo izquierdo
		return getLeftTree()->getMinor();
	}

	else{ //El nodo raíz no tiene un subárbol hijo izquierdo, por lo tanto, es el que contiene el ítem menor
		return getItem();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x40a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x31d1
jmp 0x31d3
jmp 0x31f2
leaq 0x709d(%rip), %rdi      # 0xa277
leaq 0x6f5c(%rip), %rsi      # 0xa13d
movl $0x93, %edx
leaq 0x7095(%rip), %rcx      # 0xa282
callq 0x2140
movq -0x18(%rbp), %rdi
callq 0x3f10
testb $0x1, %al
jne 0x3201
jmp 0x3218
movq -0x18(%rbp), %rdi
callq 0x3f40
movq %rax, %rdi
callq 0x31b0
movq %rax, -0x8(%rbp)
jmp 0x3226
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::setEstudiante(ed::Estudiante const&)
void ed::NodoEnlazadoArbolBinarioEstudiante::setEstudiante(ed::Estudiante const &item){
	//Precondición
	#ifndef NDEBUG
		assert(exists(item));
	#endif

	if(item==getItem()){ //El nodo raíz contiene el ítem a modificar
		setItem(item); //Modificamos el ítem
	}
	
	else if(item<getItem()){ //El ítem es menor que el ítem del nodo actual
		getLeftTree()->setEstudiante(item); //Buscamos el ítem en el subárbol hijo izquierdo
	}
	
	else{ //El item es mayor que el item del nodo actual
		getRightTree()->setEstudiante(item); //Buscamos el ítem en el subárbol hijo derecho
	}

	//Postcondición
	#ifndef NDEBUG
		assert(exists(item));
	#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2e80
testb $0x1, %al
jne 0x3257
jmp 0x3259
jmp 0x3278
leaq 0x70c5(%rip), %rdi      # 0xa325
leaq 0x6ed6(%rip), %rsi      # 0xa13d
movl $0xa2, %edx
leaq 0x705e(%rip), %rcx      # 0xa2d1
callq 0x2140
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x2960
testb $0x1, %al
jne 0x329c
jmp 0x32ac
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x32fe
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x29e0
testb $0x1, %al
jne 0x32d0
jmp 0x32e7
movq -0x18(%rbp), %rdi
callq 0x3f40
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3230
jmp 0x32fc
movq -0x18(%rbp), %rdi
callq 0x3f90
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3230
jmp 0x32fe
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e80
testb $0x1, %al
jne 0x3311
jmp 0x3313
jmp 0x3332
leaq 0x700b(%rip), %rdi      # 0xa325
leaq 0x6e1c(%rip), %rsi      # 0xa13d
movl $0xb3, %edx
leaq 0x6fa4(%rip), %rcx      # 0xa2d1
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::inorder()
void ed::NodoEnlazadoArbolBinarioEstudiante::inorder(){
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty());
	#endif

	if(hasLeftTree()){ //El nodo actual tiene hijo izquierdo
		getLeftTree()->inorder(); //Escribimos inorden el subárbol hijo izquierdo
	}

	getItem().escribirEstudiante(); //Escribimos el ítem del nodo actual
	std::cout << std::endl;

	if(hasRightTree()){ //El nodo actual tiene hijo derecho
		getRightTree()->inorder(); //Escribimos inorden el subárbol hijo derecho
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x40a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x3dc1
jmp 0x3dc3
jmp 0x3de2
leaq 0x64ad(%rip), %rdi      # 0xa277
leaq 0x636c(%rip), %rsi      # 0xa13d
movl $0x166, %edx            # imm = 0x166
leaq 0x65f8(%rip), %rcx      # 0xa3d5
callq 0x2140
movq -0x10(%rbp), %rdi
callq 0x3f10
testb $0x1, %al
jne 0x3df1
jmp 0x3e02
movq -0x10(%rbp), %rdi
callq 0x3f40
movq %rax, %rdi
callq 0x3da0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
callq 0x2670
movq 0xb1b5(%rip), %rdi      # 0xefd0
movq 0xb19e(%rip), %rsi      # 0xefc0
callq 0x21c0
movq -0x10(%rbp), %rdi
callq 0x3f60
testb $0x1, %al
jne 0x3e36
jmp 0x3e47
movq -0x10(%rbp), %rdi
callq 0x3f90
movq %rax, %rdi
callq 0x3da0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::grabar(std::basic_ofstream<char, std::char_traits<char>>&)
void ed::NodoEnlazadoArbolBinarioEstudiante::grabar(std::ofstream &fichero){
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty());
	#endif

	fichero << getItem(); //Grabamos el ítem del nodo actual

	if(hasLeftTree()){ //El nodo actual tiene hijo izquierdo
		getLeftTree()->grabar(fichero); //Grabamos los ítems del subárbol hijo izquierdo
	}

	if(hasRightTree()){ //El nodo actual tiene hijo derecho
		getRightTree()->grabar(fichero); //Grabamos los ítems del subárbol hijo derecho
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x40a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x3e75
jmp 0x3e77
jmp 0x3e96
leaq 0x63f9(%rip), %rdi      # 0xa277
leaq 0x62b8(%rip), %rsi      # 0xa13d
movl $0x178, %edx            # imm = 0x178
leaq 0x657b(%rip), %rcx      # 0xa40c
callq 0x2140
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x2b00
movq -0x18(%rbp), %rdi
callq 0x3f10
testb $0x1, %al
jne 0x3ec3
jmp 0x3ed8
movq -0x18(%rbp), %rdi
callq 0x3f40
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3e50
movq -0x18(%rbp), %rdi
callq 0x3f60
testb $0x1, %al
jne 0x3ee7
jmp 0x3efc
movq -0x18(%rbp), %rdi
callq 0x3f90
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3e50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./nodoEnlazadoArbolBinarioEstudiante.hpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::NodoEnlazadoArbolBinarioEstudiante()
inline NodoEnlazadoArbolBinarioEstudiante(){
			this->_item = NULL;
			this->setLeftTree(NULL);
			this->setRightTree(NULL);
			this->setParent(NULL);
			
			//Postcondición
			#ifndef NDEBUG
				assert(getLeftTree()==NULL and getRightTree()==NULL and getParent()==NULL);
			#endif
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x45d0
movq -0x28(%rbp), %rdi
leaq 0xaa6c(%rip), %rax      # 0xeb50
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x20(%rbp)
callq 0x3fb0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4000
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4050
jmp 0x4118
movq -0x28(%rbp), %rdi
callq 0x3f40
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
jne 0x4163
movq -0x28(%rbp), %rdi
callq 0x3f90
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
jne 0x4163
movq -0x28(%rbp), %rdi
callq 0x4360
movq %rax, -0x38(%rbp)
jmp 0x4155
movq -0x38(%rbp), %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x416c
jmp 0x416e
jmp 0x41a4
leaq 0x6466(%rip), %rdi      # 0xa5db
leaq 0x62ec(%rip), %rsi      # 0xa468
movl $0x4a, %edx
leaq 0x6496(%rip), %rcx      # 0xa61e
callq 0x2140
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x47c0
jmp 0x41aa
addq $0x40, %rsp
popq %rbp
retq
jmp 0x41ac
movq -0x10(%rbp), %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x45c0
nopl (%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::~Estudiante()
~Estudiante(){
		this->setNombre("");
		this->setApellidos("");

		this->setTeoria(0.0);
		this->setPractica(0.0);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0xa7ea(%rip), %rcx      # 0xebd8
movq %rcx, (%rax)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x22c0
movq -0x78(%rbp), %rdx
leaq 0x6624(%rip), %rsi      # 0xaa2d
leaq -0x28(%rbp), %rdi
callq 0x2210
jmp 0x4414
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
leaq -0x28(%rbp), %rsi
callq *%rax
jmp 0x4427
leaq -0x28(%rbp), %rdi
callq 0x2120
jmp 0x4432
leaq -0x29(%rbp), %rdi
callq 0x21d0
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x22c0
movq -0x88(%rbp), %rdx
leaq 0x65d4(%rip), %rsi      # 0xaa2d
leaq -0x60(%rbp), %rdi
callq 0x2210
jmp 0x4464
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
leaq -0x60(%rbp), %rsi
callq *%rax
jmp 0x4477
leaq -0x60(%rbp), %rdi
callq 0x2120
jmp 0x4482
leaq -0x61(%rbp), %rdi
callq 0x21d0
movq -0x80(%rbp), %rdi
movl $0x0, -0x68(%rbp)
movq (%rdi), %rax
movq 0x40(%rax), %rax
leaq -0x68(%rbp), %rsi
callq *%rax
jmp 0x44a5
movq -0x80(%rbp), %rdi
movl $0x0, -0x6c(%rbp)
movq (%rdi), %rax
movq 0x48(%rax), %rax
leaq -0x6c(%rbp), %rsi
callq *%rax
jmp 0x44bf
movq -0x80(%rbp), %rdi
addq $0x28, %rdi
callq 0x2120
jmp 0x44ce
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x2120
jmp 0x44dd
movq -0x80(%rbp), %rdi
callq 0x4a70
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4516
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2120
jmp 0x4514
jmp 0x4516
leaq -0x29(%rbp), %rdi
callq 0x21d0
jmp 0x456f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4548
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2120
jmp 0x4546
jmp 0x4548
leaq -0x61(%rbp), %rdi
callq 0x21d0
jmp 0x456f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x456f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x458e
movq -0x80(%rbp), %rdi
addq $0x28, %rdi
callq 0x2120
jmp 0x457e
jmp 0x458e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x459f
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x2120
jmp 0x459d
jmp 0x459f
movq -0x80(%rbp), %rdi
callq 0x4a70
movq -0x38(%rbp), %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x45c0
nopl (%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./nodoEnlazadoArbolBinarioEstudiante.hpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::setItem(ed::Estudiante const&)
inline void setItem(ed::Estudiante const & nuevoItem){
			//Si el ítem actual es nulo
			if (this->_item == NULL){
				//Se reserva memoria y se copia el nuevo ítem
				this->_item = new Estudiante(nuevoItem);
			}

			//Si ya se ha reservado memoria para ítem
			else{
				//Se copia el nuevo ítem en el ítem actual
				*(this->_item) = nuevoItem;
			}
			
			//Postcondición
			#ifndef NDEBUG
				assert(getItem()==nuevoItem);
			#endif
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x4763
movl $0x50, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x41c0
jmp 0x473e
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x4774
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2190
jmp 0x47b7
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x8(%rax), %rdi
callq 0x2890
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2960
testb $0x1, %al
jne 0x4790
jmp 0x4792
jmp 0x47b1
leaq 0x5f41(%rip), %rdi      # 0xa6da
leaq 0x5cc8(%rip), %rsi      # 0xa468
movl $0x124, %edx            # imm = 0x124
leaq 0x5f43(%rip), %rcx      # 0xa6ef
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22b0
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/asignatura.cpp
// Function: ed::Asignatura::grabarFichero(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool ed::Asignatura::grabarFichero(std::string const &nombreFichero){
	std::ofstream fichero;

	fichero.open(nombreFichero.c_str()); //Abrimos el fichero con el nombre recibido

	if(!fichero){ //No se ha podido abrir el fichero
		return false;
	}

	else{ //Se ha podido abrir el fichero
		//Escribimos en el fichero el nombre y el código de la asignatura
		fichero << getNombre() << std::endl;
		fichero << getCodigo() << std::endl;

		_arbol.grabar(fichero); //Escribimos el en fichero la lista de estudiantes

		fichero.close(); //Cerramos el fichero

		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x258(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x2290
movq -0x18(%rbp), %rdi
callq 0x20d0
movq %rax, -0x250(%rbp)
jmp 0x4f1c
movq -0x250(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x2060
jmp 0x4f36
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x2100
movb %al, -0x259(%rbp)
jmp 0x4f56
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x4f62
jmp 0x4f8c
movb $0x0, -0x1(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x5084
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x509e
movq -0x258(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x248(%rbp), %rdi
callq *%rax
jmp 0x4fa5
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x2180
movq %rax, -0x268(%rbp)
jmp 0x4fc1
movq -0x268(%rbp), %rdi
movq 0x9ff1(%rip), %rsi      # 0xefc0
callq 0x21c0
jmp 0x4fd6
leaq -0x248(%rbp), %rdi
callq 0x2120
jmp 0x4fe4
movq -0x258(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x26c(%rbp)
jmp 0x4ffb
movl -0x26c(%rbp), %esi
leaq -0x218(%rbp), %rdi
callq 0x22a0
movq %rax, -0x278(%rbp)
jmp 0x5016
movq -0x278(%rbp), %rdi
movq 0x9f9c(%rip), %rsi      # 0xefc0
callq 0x21c0
jmp 0x502b
movq -0x258(%rbp), %rdi
addq $0x30, %rdi
leaq -0x218(%rbp), %rsi
callq 0x3e50
jmp 0x5044
leaq -0x218(%rbp), %rdi
callq 0x2240
jmp 0x5052
movb $0x1, -0x1(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x5084
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x2120
jmp 0x5082
jmp 0x509e
leaq -0x218(%rbp), %rdi
callq 0x2250
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x2250
jmp 0x50ac
jmp 0x50ae
movq -0x220(%rbp), %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::insertarEstudiante(ed::Estudiante const&)
inline bool insertarEstudiante(ed::Estudiante const &estudiante){
		//Precondición
		#ifndef NDEBUG
			assert(!existeEstudiante(estudiante));
		#endif

		int old=getNumeroEstudiantes();

		if(existeEstudiante(estudiante)){ //Ya existe el estudiante
			return false;
		}

		else{ //No existe el estudiante
			_arbol.insert(estudiante); //Insertamos el estudiante

			//Postcondición
			#ifndef NDEBUG
				assert(existeEstudiante(estudiante) and old==getNumeroEstudiantes()-1);
			#endif

			return true;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0x52f0
xorb $-0x1, %al
testb $0x1, %al
jne 0x5219
jmp 0x521b
jmp 0x523a
leaq 0x5710(%rip), %rdi      # 0xa932
leaq 0x5727(%rip), %rsi      # 0xa950
movl $0x141, %edx            # imm = 0x141
leaq 0x572c(%rip), %rcx      # 0xa961
callq 0x2140
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rsi
callq 0x52f0
testb $0x1, %al
jne 0x525a
jmp 0x5260
movb $0x0, -0x1(%rbp)
jmp 0x52da
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x3340
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x52f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x528c
jmp 0x52ac
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movl -0x30(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x52b5
jmp 0x52b7
jmp 0x52d6
leaq 0x56e3(%rip), %rdi      # 0xa9a1
leaq 0x568b(%rip), %rsi      # 0xa950
movl $0x14f, %edx            # imm = 0x14F
leaq 0x5690(%rip), %rcx      # 0xa961
callq 0x2140
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/funcionesAuxiliares.cpp
// Function: ed::comprobarAsignaturaVacia(ed::Asignatura const&)
void ed::comprobarAsignaturaVacia(ed::Asignatura const &asignatura){
	std::cout << std::endl << IPURPLE "La asignatura de nombre < " << asignatura.getNombre() << " > ";

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq 0x996d(%rip), %rdi      # 0xefd0
movq 0x9956(%rip), %rsi      # 0xefc0
callq 0x21c0
movq %rax, %rdi
leaq 0x5553(%rip), %rsi      # 0xabcc
callq 0x21a0
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 0x2180
movq %rax, -0x40(%rbp)
jmp 0x56aa
movq -0x40(%rbp), %rdi
leaq 0x5539(%rip), %rsi      # 0xabee
callq 0x21a0
jmp 0x56bc
leaq -0x28(%rbp), %rdi
callq 0x2120
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x56d5
jmp 0x5712
movq 0x98f4(%rip), %rdi      # 0xefd0
leaq 0x5372(%rip), %rsi      # 0xaa55
callq 0x21a0
movq %rax, %rdi
leaq 0x58c9(%rip), %rsi      # 0xafbb
callq 0x21a0
jmp 0x5734
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2120
jmp 0x5710
jmp 0x573a
movq 0x98b7(%rip), %rdi      # 0xefd0
leaq 0x54d2(%rip), %rsi      # 0xabf2
callq 0x21a0
movq %rax, %rdi
leaq 0x588c(%rip), %rsi      # 0xafbb
callq 0x21a0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x45c0
nopl (%rax,%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/funcionesAuxiliares.cpp
// Function: ed::borrarAsignatura(ed::Asignatura&)
void ed::borrarAsignatura(ed::Asignatura &asignatura){
	asignatura.setCodigo(0); //Borramos el código de la asignatura
	asignatura.setNombre(""); //Borramos el nombre de la asignatura

	//Borramos la lista de estudiantes
	while(!asignatura.estaVacia()){	
		asignatura.borrarEstudiante(0);
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 0x22c0
movq -0x48(%rbp), %rdx
leaq 0x5062(%rip), %rsi      # 0xaa2d
leaq -0x28(%rbp), %rdi
callq 0x2210
jmp 0x59d6
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
leaq -0x28(%rbp), %rsi
callq *%rax
jmp 0x59e9
leaq -0x28(%rbp), %rdi
callq 0x2120
jmp 0x59f4
leaq -0x29(%rbp), %rdi
callq 0x21d0
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x5a0f
jmp 0x5a4e
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x83c0
jmp 0x59fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5a43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2120
jmp 0x5a41
jmp 0x5a43
leaq -0x29(%rbp), %rdi
callq 0x21d0
jmp 0x5aa3
movq 0x957b(%rip), %rdi      # 0xefd0
movq 0x9564(%rip), %rsi      # 0xefc0
callq 0x21c0
movq %rax, %rdi
leaq 0x51f4(%rip), %rsi      # 0xac5f
callq 0x21a0
movq %rax, %rdi
leaq 0x53bf(%rip), %rsi      # 0xae39
callq 0x21a0
movq %rax, %rdi
leaq 0x5532(%rip), %rsi      # 0xafbb
callq 0x21a0
movq %rax, %rdi
movq 0x9528(%rip), %rsi      # 0xefc0
callq 0x21c0
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::borrarEstudiante(int)
inline bool borrarEstudiante(int pos){
		//Precondición
		#ifndef NDEBUG
			assert(pos<=getNumeroEstudiantes());
		#endif

		int old=getNumeroEstudiantes();

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

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

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

			return true;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jg 0x83ee
jmp 0x840d
leaq 0x2d56(%rip), %rdi      # 0xb14b
leaq 0x2554(%rip), %rsi      # 0xa950
movl $0x1ad, %edx            # imm = 0x1AD
leaq 0x2d5f(%rip), %rcx      # 0xb167
callq 0x2140
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x28(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jle 0x8439
movb $0x0, -0x1(%rbp)
jmp 0x84a1
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
addq $0x30, %rdi
movl -0x14(%rbp), %esi
callq 0x3040
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3570
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movl -0x30(%rbp), %eax
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x847e
jmp 0x849d
leaq 0x2dd6(%rip), %rdi      # 0xb25b
leaq 0x24c4(%rip), %rsi      # 0xa950
movl $0x1bb, %edx            # imm = 0x1BB
leaq 0x2ccf(%rip), %rcx      # 0xb167
callq 0x2140
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::borrarEstudiante(ed::Estudiante const&)
inline bool borrarEstudiante(ed::Estudiante const &estudiante){
		//Precondición
		#ifndef NDEBUG
			assert(existeEstudiante(estudiante.getNombre(),estudiante.getApellidos()));
		#endif

		int old=getNumeroEstudiantes();

		if(!existeEstudiante(estudiante)){ //No existe el estudiante
			return false;
		}

		else{ //Sí existe el estudiante
			_arbol.remove(estudiante); //Borramos el estudiante

			//Postcondición
			#ifndef NDEBUG
				assert(!existeEstudiante(estudiante.getNombre(),estudiante.getApellidos()) and old==getNumeroEstudiantes()+1);
			#endif

			return true;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x84f7
jmp 0x84f9
jmp 0x8518
leaq 0x2c92(%rip), %rdi      # 0xb192
leaq 0x2449(%rip), %rsi      # 0xa950
movl $0x18a, %edx            # imm = 0x18A
leaq 0x2cc2(%rip), %rcx      # 0xb1d5
callq 0x2140
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x30(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rsi
callq 0x52f0
testb $0x1, %al
jne 0x853f
movb $0x0, -0x1(%rbp)
jmp 0x85d3
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x3570
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x85a5
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movl -0x44(%rbp), %eax
addl $0x1, %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x85ae
jmp 0x85b0
jmp 0x85cf
leaq 0x2c5c(%rip), %rdi      # 0xb213
leaq 0x2392(%rip), %rsi      # 0xa950
movl $0x198, %edx            # imm = 0x198
leaq 0x2c0b(%rip), %rcx      # 0xb1d5
callq 0x2140
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::setEstudiante(ed::Estudiante const&)
inline void setEstudiante(ed::Estudiante const &e){
		//Precondición
		#ifndef NDEBUG
			assert(existeEstudiante(e));
		#endif

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x52f0
testb $0x1, %al
jne 0x8607
jmp 0x8609
jmp 0x8628
leaq 0x2c69(%rip), %rdi      # 0xb279
leaq 0x2339(%rip), %rsi      # 0xa950
movl $0x100, %edx            # imm = 0x100
leaq 0x2c6a(%rip), %rcx      # 0xb28d
callq 0x2140
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x3230
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x52f0
testb $0x1, %al
jne 0x864c
jmp 0x864e
jmp 0x866d
leaq 0x2c24(%rip), %rdi      # 0xb279
leaq 0x22f4(%rip), %rsi      # 0xa950
movl $0x107, %edx            # imm = 0x107
leaq 0x2c25(%rip), %rcx      # 0xb28d
callq 0x2140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::existeEstudiante(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool existeEstudiante(std::string const &nombre, std::string const &apellidos){
		// Se crea un estudiante auxiliar con el nombre y los apellidos
		ed::Estudiante estudiante(nombre,apellidos,0,0);
   
		// Se llama a la función exists de _arbol
		return this->_arbol.exists(estudiante); 
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x20e0
movq -0x18(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x20e0
jmp 0x8ef4
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x50d0
jmp 0x8f13
leaq -0xa8(%rbp), %rdi
callq 0x2120
jmp 0x8f21
leaq -0x88(%rbp), %rdi
callq 0x2120
movq -0xc0(%rbp), %rdi
addq $0x30, %rdi
leaq -0x68(%rbp), %rsi
callq 0x2e80
movb %al, -0xc1(%rbp)
jmp 0x8f49
leaq -0x68(%rbp), %rdi
callq 0x43d0
movb -0xc1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x8f99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2120
jmp 0x8f97
jmp 0x8f99
leaq -0x88(%rbp), %rdi
callq 0x2120
jmp 0x8fa7
jmp 0x8fc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x43d0
jmp 0x8fc6
jmp 0x8fc8
movq -0xb0(%rbp), %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x45c0
nopl (%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::getEstudiante(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline ed::Estudiante const & getEstudiante(std::string const &nombre, std::string const &apellidos){
		//Precondición
		#ifndef NDEBUG
			assert(existeEstudiante(nombre,apellidos));
		#endif

		ed::Estudiante estudiante(nombre,apellidos,0,0); //Creamos un estudiante con los datos recibidos

		return _arbol.getEstudiante(estudiante); //Devolvemos el estudiante a buscar
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x9016
jmp 0x9018
jmp 0x9037
leaq 0x249a(%rip), %rdi      # 0xb4b9
leaq 0x192a(%rip), %rsi      # 0xa950
movl $0x9a, %edx
leaq 0x2344(%rip), %rcx      # 0xb376
callq 0x2140
movq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x20e0
movq -0x18(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x20e0
jmp 0x9059
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x50d0
jmp 0x9078
leaq -0xa8(%rbp), %rdi
callq 0x2120
jmp 0x9086
leaq -0x88(%rbp), %rdi
callq 0x2120
movq -0xc0(%rbp), %rdi
addq $0x30, %rdi
leaq -0x68(%rbp), %rsi
callq 0x2f60
movq %rax, -0xc8(%rbp)
jmp 0x90af
leaq -0x68(%rbp), %rdi
callq 0x43d0
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x90fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2120
jmp 0x90fc
jmp 0x90fe
leaq -0x88(%rbp), %rdi
callq 0x2120
jmp 0x910c
jmp 0x912d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x43d0
jmp 0x912b
jmp 0x912d
movq -0xb0(%rbp), %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./asignatura.hpp
// Function: ed::Asignatura::setNombre(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline  void setNombre(std::string const & nombre){
		this->_nombre = nombre;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getNombre()==nombre);
		#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
addq $0x10, %rdi
callq 0x2040
movq -0x50(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq *%rax
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2bd0
movb %al, -0x3d(%rbp)
jmp 0x925c
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x9265
jmp 0x9267
jmp 0x929d
leaq 0x14d6(%rip), %rdi      # 0xa744
leaq 0x16db(%rip), %rsi      # 0xa950
movl $0xef, %edx
leaq 0x21fb(%rip), %rcx      # 0xb47c
callq 0x2140
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2120
jmp 0x92ac
leaq -0x30(%rbp), %rdi
callq 0x2120
addq $0x50, %rsp
popq %rbp
retq
jmp 0x92ae
movq -0x38(%rbp), %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x45c0
nop
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::Graph(Graph const&)
Graph::Graph(const Graph &graph) {
    nodeIndex = graph.nodeIndex;
    zeroDegreeNodes = graph.zeroDegreeNodes;
    nextUnusedId = graph.nextUnusedId;
    mapping = graph.mapping;
    edgeBuffer = new vector<uint32_t>(*(graph.edgeBuffer));
    if (graph.mapping) {
        idToPos = new unordered_map<uint32_t, uint32_t>(*(graph.idToPos));
        posToId = new vector<uint32_t>(*(graph.posToId));
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
callq 0x17e50
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x28(%rsp)
callq 0x17e60
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x17e70
jmp 0x26a9
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x18130
jmp 0x26c2
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x38(%rax)
movq 0x48(%rsp), %rcx
movb 0x3c(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x3c(%rax)
movl $0x18, %edi
callq 0x21b0
movq %rax, 0x18(%rsp)
jmp 0x26f1
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x183f0
jmp 0x2706
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x48(%rsp), %rax
testb $0x1, 0x3c(%rax)
je 0x27eb
movl $0x38, %edi
callq 0x21b0
movq %rax, 0x10(%rsp)
jmp 0x2734
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x184f0
jmp 0x2749
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x40(%rax)
movl $0x18, %edi
callq 0x21b0
movq %rax, 0x8(%rsp)
jmp 0x2768
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x183f0
jmp 0x277d
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x48(%rax)
jmp 0x27eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x27f0
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x2180
jmp 0x27f0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x2180
jmp 0x27f0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x2180
jmp 0x27f0
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x18520
movq 0x30(%rsp), %rdi
callq 0x18580
movq 0x40(%rsp), %rdi
callq 0x2310
nop
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::operator=(Graph const&)
Graph& Graph::operator=(const Graph &graph) {
    if (this != &graph) {
        nodeIndex = graph.nodeIndex;
        zeroDegreeNodes = graph.zeroDegreeNodes;
        nextUnusedId = graph.nextUnusedId;
        mapping = graph.mapping;
        edgeBuffer = new vector<uint32_t>(*(graph.edgeBuffer));
        if (graph.mapping) {
            idToPos = new unordered_map<uint32_t, uint32_t>(*(graph.idToPos));
            posToId = new vector<uint32_t>(*(graph.posToId));
        }
    }
    return *this;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq 0x38(%rsp), %rax
je 0x2971
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x17e70
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x18130
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x38(%rax)
movq 0x38(%rsp), %rcx
movb 0x3c(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x3c(%rax)
movl $0x18, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x183f0
jmp 0x289c
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rax
testb $0x1, 0x3c(%rax)
je 0x296f
movl $0x38, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x184f0
jmp 0x28de
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x40(%rax)
movl $0x18, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x183f0
jmp 0x2911
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x48(%rax)
jmp 0x296f
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x2180
jmp 0x297b
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x2180
jmp 0x297b
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x2180
jmp 0x297b
jmp 0x2971
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::~Graph()
Graph::~Graph() {
    delete edgeBuffer;
    if (mapping) {
        delete idToPos;
        delete posToId;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x29c6
movq 0x18(%rsp), %rdi
callq 0x18520
movq 0x18(%rsp), %rdi
callq 0x2180
movq 0x10(%rsp), %rax
testb $0x1, 0x3c(%rax)
je 0x2a20
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x29f9
movq 0x8(%rsp), %rdi
callq 0x185e0
movq 0x8(%rsp), %rdi
callq 0x2180
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2a1e
movq (%rsp), %rdi
callq 0x18520
movq (%rsp), %rdi
callq 0x2180
jmp 0x2a20
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x18520
movq 0x10(%rsp), %rdi
callq 0x18580
addq $0x28, %rsp
retq
nopl (%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getMaxNodeDegree(unsigned int&, unsigned int&, unsigned int const&) const
void Graph::getMaxNodeDegree(uint32_t &node, uint32_t &maxDegree, const uint32_t &bound) const {
    node = NONE;
    maxDegree = 0;
    for (uint32_t i = 0 ; i < nodeIndex.size() ; i++) {
        if (!nodeIndex[i].removed && nodeIndex[i].edges > maxDegree) {
            node = (!mapping ? i : posToId->at(i));
            maxDegree = nodeIndex[i].edges;
            if (bound != NONE && maxDegree >= bound) {
                return;
            }
        }
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movq %rax, 0x10(%rsp)
callq 0x18830
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x2bbe
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x18850
testb $0x1, 0x8(%rax)
jne 0x2bac
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x18850
movl 0x4(%rax), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jbe 0x2bac
movq 0x18(%rsp), %rax
testb $0x1, 0x3c(%rax)
jne 0x2b4f
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x2b69
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x18870
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x18850
movl 0x4(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
cmpl $-0x1, (%rax)
je 0x2baa
movq 0x30(%rsp), %rax
movl (%rax), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jb 0x2baa
jmp 0x2bbe
jmp 0x2bac
jmp 0x2bae
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2ae0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getMinDegree(unsigned int&) const
void Graph::getMinDegree(uint32_t &minDegree) const {
    minDegree = NONE;
    for (uint32_t i = 0 ; i < nodeIndex.size() ; i++) {
        if (!nodeIndex[i].removed && nodeIndex[i].edges && nodeIndex[i].edges < minDegree) {
            minDegree = nodeIndex[i].edges;
            if (minDegree < 3) {
                return;
            }
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movq %rax, (%rsp)
callq 0x18830
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x2c9f
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x18850
testb $0x1, 0x8(%rax)
jne 0x2c8d
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x18850
cmpl $0x0, 0x4(%rax)
je 0x2c8d
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x18850
movl 0x4(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x2c8d
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x18850
movl 0x4(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
cmpl $0x3, (%rax)
jae 0x2c8b
jmp 0x2c9f
jmp 0x2c8d
jmp 0x2c8f
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2bfb
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getTotalEdges() const
uint32_t Graph::getTotalEdges() const {
    uint32_t count = 0;
    for (uint32_t pos = 0 ; pos < nodeIndex.size() ; pos++) {
        if (!nodeIndex[pos].removed) {
            count += nodeIndex[pos].edges;
        }
    }
    return count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movq %rax, 0x8(%rsp)
callq 0x18830
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2d33
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x18850
testb $0x1, 0x8(%rax)
jne 0x2d24
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x18850
movl 0x4(%rax), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x2d26
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2cd3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)