LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Utility::ReadBom(_IO_FILE*)
static BomType ReadBom(FILE* file) {
			char btBom[5] = { 0, };
			size_t readSize = fread(btBom, sizeof(char), 5, file);


			if (0 == readSize) {
				clearerr(file);
				fseek(file, 0, SEEK_SET);

				return BomType::ANSI;
			}

			BomInfo stBom = { 0, };
			BomType type = ReadBom(btBom, readSize, stBom);

			if (type == BomType::ANSI) { // ansi
				clearerr(file);
				fseek(file, 0, SEEK_SET);
				return BomType::ANSI;
			}

			clearerr(file);
			fseek(file, static_cast<long>(stBom.bom_size * sizeof(char)), SEEK_SET);
			return type;
		}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movb $0x0, 0x4(%rdi)
andl $0x0, (%rdi)
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rcx
callq 0x22a0
testq %rax, %rax
je 0x585a
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6008
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2060
xorl %esi, %esi
cmpl $0x1, %ebp
je 0x584e
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x21f0
jmp 0x5871
movq %rbx, %rdi
callq 0x2060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21f0
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Utility::ReadBom(char const*, unsigned long, clau_parser::Utility::BomInfo&)
static BomType ReadBom(const char* contents, size_t length, BomInfo& outInfo) {
			char btBom[5] = { 0, };
			size_t testLength = length < 5 ? length : 5;
			memcpy(btBom, contents, testLength);

			size_t i, j;
			for (i = 0; i < BOM_COUNT; ++i) {
				const BomInfo& bom = bomInfo[i];

				if (bom.bom_size > testLength) {
					continue;
				}

				bool matched = true;

				for (j = 0; j < bom.bom_size; ++j) {
					if (bom.seq[j] == btBom[j]) {
						continue;
					}

					matched = false;
					break;
				}

				if (!matched) {
					continue;
				}

				outInfo = bom;

				return (BomType)i;
			}

			return BomType::ANSI;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %rsp, %rdi
movb $0x0, 0x4(%rdi)
andl $0x0, (%rdi)
cmpq $0x5, %r14
pushq $0x5
popq %rdx
cmovbq %r14, %rdx
callq 0x2150
pushq $0x1
popq %rax
cmpq $0x3, %r14
jb 0x6067
xorl %ecx, %ecx
leaq 0x323f(%rip), %rdx      # 0x9280
cmpq $0x3, %rcx
je 0x605b
movb 0x8(%rcx,%rdx), %sil
leaq 0x1(%rcx), %rdi
cmpb (%rsp,%rcx), %sil
movq %rdi, %rcx
je 0x6041
jmp 0x6067
movaps 0x321e(%rip), %xmm0     # 0x9280
movups %xmm0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Utility::Get(long, char)
static int64_t Get(int64_t position, char ch) {
			int64_t length = 1;

			int64_t x = (position << 32) + (length << 3) + 0;

			x += 2 * (LoadDataOption::Left == ch ? 1 : 0);
			x += 4 * (LoadDataOption::Right == ch ? 1 : 0);
			x += 6 * (LoadDataOption::Assignment == ch ? 1 : 0);

			return x;
		}

// Assembly:
shlq $0x20, %rdi
xorl %eax, %eax
cmpb $0x7b, %sil
sete %al
xorl %ecx, %ecx
cmpb $0x7d, %sil
sete %cl
cmpb $0x3d, %sil
leaq (%rdi,%rax,2), %rax
leaq (%rax,%rcx,4), %rdx
leaq 0x6(%rax,%rcx,4), %rax
cmovneq %rdx, %rax
addq $0x8, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Utility::ReadBom(char const*, unsigned long)
static BomType ReadBom(const char* contents, size_t length) {
			char btBom[5] = { 0, };
			size_t readSize = std::min((size_t)5, length);


			if (0 == readSize) {
				return BomType::ANSI;
			}

			BomInfo stBom = { 0, };
			BomType type = ReadBom(btBom, readSize, stBom);

			if (type == BomType::ANSI) { // ansi
				return BomType::ANSI;
			}

			return type;
		}

// Assembly:
subq $0x28, %rsp
movb $0x0, 0xc(%rsp)
andl $0x0, 0x8(%rsp)
testq %rsi, %rsi
je 0x6a08
cmpq $0x5, %rsi
pushq $0x5
popq %rax
cmovbq %rsi, %rax
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6008
jmp 0x6a0b
pushq $0x1
popq %rax
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::AddUserTypeItem(clau_parser::UserType const&)
void AddUserTypeItem(const UserType& item) {
			UserType* temp = new UserType(item);
			temp->parent = this;

			ilist.push_back(2);

			userTypeList.push_back(temp);

			useSortedUserTypeList = false;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0xb0, %edi
callq 0x21c0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x78ea
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq %rbx, 0x28(%r14)
leaq 0x30(%rbx), %rdi
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
callq 0x3780
leaq 0x60(%rbx), %rdi
movq %r15, %rsi
callq 0x31f6
movb $0x0, 0xa9(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xb0, %esi
movq %r14, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::Remove()
void Remove()
		{
			ilist = std::vector<int>();
			itemList = std::vector< ItemType<std::string> >();

			RemoveUserTypeList();

			sortedItemList.clear();
			sortedUserTypeList.clear();

			useSortedItemList = false;
			useSortedUserTypeList = false;
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x30, %rdi
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %r14, %rsi
callq 0x3af0
movq %r14, %rdi
callq 0x3b42
leaq 0x48(%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rsp, %r14
movq %r14, %rsi
callq 0x3a56
movq %r14, %rdi
callq 0x3aa8
movq %rbx, %rdi
callq 0x84b0
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x74a4
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x74bb
movq %rax, 0x98(%rbx)
andw $0x0, 0xa8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::LoadData::check_syntax_error1(long, int*)
static int64_t check_syntax_error1(int64_t str, int* err) {
			int64_t len = Utility::GetLength(str);
			int64_t type = Utility::GetType(str);

			if (1 == len && (type == TYPE_LEFT || type == TYPE_RIGHT ||
				type == TYPE_ASSIGN)) {
				*err = -4;
				//std::cout << "err " << type << "\n";
			}
			return str;
		}

// Assembly:
movq %rdi, %rax
movl %eax, %ecx
andl $-0x8, %ecx
cmpl $0x8, %ecx
jne 0x74ef
movl %eax, %ecx
shrl %ecx
andl $0x3, %ecx
decq %rcx
cmpq $0x2, %rcx
ja 0x74ef
movl $0xfffffffc, (%rsi)     # imm = 0xFFFFFFFC
retq
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::ItemType<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(clau_parser::ItemType<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
ItemType<T>& operator=(const ItemType<T>& ta)
		{
			Type::operator=(ta);
			ItemType<T> temp = ta;

			data = std::move(temp.data);
			inited = temp.inited;
			return *this;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x2110
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8068
leaq 0x28(%rsp), %rbx
leaq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x2220
movb 0x20(%rbx), %al
movb %al, 0x48(%r14)
movq %r15, %rdi
callq 0x3596
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::RemoveUserTypeList()
void RemoveUserTypeList() {
			for (size_t i = 0; i < userTypeList.size(); i++) {
				if (nullptr != userTypeList[i]) {
					Delete(userTypeList[i]); //
					userTypeList[i] = nullptr;
				}
			}

			userTypeList.clear();

			std::vector<int> temp;
			for (size_t i = 0; i < ilist.size(); ++i) {
				if (ilist[i] == 1)
				{
					temp.push_back(1);
				}
			}
			ilist = move(temp);

			useSortedUserTypeList = false;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r14
jae 0x84f6
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x84f1
callq 0x8592
movq 0x60(%rbx), %rax
andq $0x0, (%rax,%r14,8)
incq %r14
jmp 0x84c3
cmpq %rax, %rcx
je 0x84ff
movq %rax, 0x68(%rbx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
movaps %xmm0, (%r14)
leaq 0x30(%rbx), %r15
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r13
jae 0x854f
cmpl $0x1, (%rax,%r13,4)
jne 0x854a
movl $0x1, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3780
incq %r13
jmp 0x851c
leaq 0x10(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x3af0
movb $0x0, 0xa9(%rbx)
movq %r14, %rdi
callq 0x3b42
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3b42
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::Delete(void*)
static void Delete(void* ptr) {
			std::vector<Wrap> _stack;
			_stack.push_back(Wrap((UserType*)ptr));

			while (!_stack.empty()) {
				if (_stack.back().idx >= _stack.back().max) {
					_stack.back().ut->userTypeList.clear();

					if (_stack.back().ut) {
						delete _stack.back().ut;
					}

					_stack.pop_back();
					if (_stack.empty()) {
						break;
					}
					_stack.back().idx++;
					continue;
				}

				_stack.push_back(Wrap(_stack.back().ut->GetUserTypeList(_stack.back().idx)));
			}
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsp, %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0x20(%rsp), %rsi
movq %rdi, (%rsi)
andq $0x0, 0x8(%rsi)
movq 0x68(%rdi), %rcx
subq 0x60(%rdi), %rcx
sarq $0x3, %rcx
movq %rcx, 0x10(%rsi)
movq %rax, %rdi
callq 0x8678
movq %rsp, %rbx
leaq 0x20(%rsp), %r14
movq 0x8(%rsp), %rax
cmpq %rax, (%rsp)
je 0x8653
movq -0x10(%rax), %rcx
cmpq -0x8(%rax), %rcx
jae 0x861e
movq -0x18(%rax), %rax
movq 0x60(%rax), %rax
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movq 0x68(%rax), %rcx
subq 0x60(%rax), %rcx
sarq $0x3, %rcx
movq %rcx, 0x30(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8678
jmp 0x85d4
movq -0x18(%rax), %rdi
movq 0x60(%rdi), %rax
cmpq %rax, 0x68(%rdi)
je 0x8630
movq %rax, 0x68(%rdi)
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
leaq -0x18(%rax), %rdx
movq %rdx, 0x8(%rsp)
cmpq %rdx, %rcx
je 0x8653
incq -0x28(%rax)
jmp 0x85d4
movq %rsp, %rdi
callq 0x883e
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x8665
movq %rax, %rbx
movq %rsp, %rdi
callq 0x883e
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::Reset2(clau_parser::UserType&&)
void Reset2(UserType&& ut) {
			ilist = std::move(ut.ilist);
			itemList = std::move(ut.itemList);

			//sortedItemList = std::move(ut.sortedItemList);
			//sortedUserTypeList = std::move(ut.sortedUserTypeList);

			useSortedItemList = false; // ut.useSortedItemList;
			useSortedUserTypeList = false; // ut.useSortedUserTypeList;

			userTypeList.reserve(ut.userTypeList.size());

			for (size_t i = 0; i < ut.userTypeList.size(); ++i) {
				userTypeList.push_back(std::move(ut.userTypeList[i]));
				ut.userTypeList[i] = nullptr;
				userTypeList.back()->parent = this;
			}
			ut.userTypeList.clear();


			sortedItemList.clear();
			sortedUserTypeList.clear();

			ut.sortedItemList.clear();
			ut.sortedUserTypeList.clear();
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x3af0
leaq 0x48(%rbx), %rsi
leaq 0x48(%r14), %rdi
callq 0x3a56
andw $0x0, 0xa8(%r14)
leaq 0x60(%r14), %r15
movq 0x68(%rbx), %rsi
subq 0x60(%rbx), %rsi
sarq $0x3, %rsi
movq %r15, %rdi
callq 0x71e0
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x60(%rbx), %rsi
movq 0x68(%rbx), %rax
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x8bbe
addq %r12, %rsi
movq %r15, %rdi
callq 0x82b6
movq 0x60(%rbx), %rax
andq $0x0, (%rax,%r12)
movq 0x68(%r14), %rax
movq -0x8(%rax), %rax
movq %r14, 0x28(%rax)
incq %r13
addq $0x8, %r12
jmp 0x8b7e
cmpq %rsi, %rax
je 0x8bc7
movq %rsi, 0x68(%rbx)
movq 0x78(%r14), %rax
cmpq %rax, 0x80(%r14)
je 0x8bdb
movq %rax, 0x80(%r14)
movq 0x90(%r14), %rax
cmpq %rax, 0x98(%r14)
je 0x8bf2
movq %rax, 0x98(%r14)
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x8c06
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x8c1d
movq %rax, 0x98(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::_Remove()
void _Remove()
		{
			//parent = nullptr;
			ilist = std::vector<int>();
			itemList = std::vector< ItemType<std::string> >();

			sortedItemList.clear();
			sortedUserTypeList.clear();

			useSortedItemList = false;
			useSortedUserTypeList = false;
			RemoveUserTypeList();
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x30, %rdi
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %r14, %rsi
callq 0x3af0
movq %r14, %rdi
callq 0x3b42
leaq 0x48(%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rsp, %r14
movq %r14, %rsi
callq 0x3a56
movq %r14, %rdi
callq 0x3aa8
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x8c8c
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x8ca3
movq %rax, 0x98(%rbx)
andw $0x0, 0xa8(%rbx)
movq %rbx, %rdi
callq 0x84b0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4204
movq %rsi, %r14
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %r15
andq $0x0, 0x10(%r15)
movapd %xmm0, (%r15)
pushq $0x8
popq %r12
xorl %r13d, %r13d
pushq $0x3
popq %rbp
cmpq $0x68, %r12
je 0x41d3
leal -0x1(%r13), %eax
testq %r13, %r13
cltq
cmoveq %rbp, %rax
movq 0x18(%rsp), %rsi
imulq $0x18, %rax, %rax
movq 0x8(%r14,%rax), %rax
movq -0x8(%r14,%r12), %rdi
movq (%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 0x42ee
incq %r13
addq $0x18, %r12
jmp 0x416a
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
je 0x4213
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
jmp 0x4233
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
jmp 0x423d
movq (%r14), %rax
movupd (%rax), %xmm0
leaq 0x30(%rsp), %rsi
movapd %xmm0, (%rsi)
pushq $0x1
popq %rdx
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0x430e
leaq 0x10(%rsp), %rdi
callq 0x2fb2
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4251
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2fb2
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/estudiante.cpp
// Function: ed::Estudiante::leerEstudiante()
void ed::Estudiante::leerEstudiante(){
   std::cout << IGREEN << "Introduce el nombre: " << RESET;
// Uso de getline para leer nombres compuestos separados por espacios
   std::getline(std::cin,this->_nombre);

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7b5c(%rip), %r15      # 0x9fd0
leaq 0x3b8d(%rip), %r12      # 0x6008
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
leaq 0x3b83(%rip), %rsi      # 0x6010
movq %rax, %rdi
callq 0x2160
leaq 0x3b8a(%rip), %r13      # 0x6026
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
leaq 0x8(%rbx), %rsi
movq 0x7b2e(%rip), %r14      # 0x9fe0
movq %r14, %rdi
callq 0x2060
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
leaq 0x3b5f(%rip), %rsi      # 0x602b
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x2060
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
leaq 0x3b48(%rip), %rsi      # 0x6045
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
leaq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x2250
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
leaq 0x3b36(%rip), %rsi      # 0x6064
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
addq $0x4c, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2250
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/estudiante.cpp
// Function: ed::Estudiante::escribirEstudiante()
void ed::Estudiante::escribirEstudiante(){
  std::cout << IYELLOW << "Nombre:" << this->getNombre() << RESET << std::endl;

  std::cout << IYELLOW << "Apellidos:" << this->getApellidos() << RESET << std::endl;

  std::cout << IYELLOW << "Nota de teoría:" << this->getTeoria() << RESET << std::endl;

  std::cout << IYELLOW << "Nota de prácticas:" << this->getPractica() << RESET << std::endl;

  std::cout << IYELLOW << "Nota final:" << this->getFinal() << RESET << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7a52(%rip), %r14      # 0x9fd0
leaq 0x3b00(%rip), %r15      # 0x6085
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x3af6(%rip), %rsi      # 0x608d
movq %rax, %rdi
callq 0x2160
movq %rax, %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x2140
leaq 0x3a6a(%rip), %r12      # 0x6026
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x3ab4(%rip), %rsi      # 0x6095
movq %rax, %rdi
callq 0x2160
movq %rax, %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x2140
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x3a7b(%rip), %rsi      # 0x60a0
movq %rax, %rdi
callq 0x2160
movq %rax, %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r13, %rdi
callq 0x2120
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x3a4b(%rip), %rsi      # 0x60b1
movq %rax, %rdi
callq 0x2160
movq %rax, %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r13, %rdi
callq 0x2120
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x3a1e(%rip), %rsi      # 0x60c5
movq %rax, %rdi
callq 0x2160
movss 0x48(%rbx), %xmm0
addss 0x4c(%rbx), %xmm0
mulss 0x3943(%rip), %xmm0     # 0x6004
movq %rax, %rdi
callq 0x2120
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/estudiante.cpp
// Function: ed::Estudiante::operator<(ed::Estudiante const&) const
bool ed::Estudiante::operator <(const ed::Estudiante & e) const{
	if (this->getApellidos() < e.getApellidos()){
       		return true;
	}

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

     	else{
   		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2935
movb $0x1, %bl
testb %al, %al
jne 0x284c
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %rax, %r12
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x284a
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2935
testb %al, %al
jne 0x284c
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/estudiante.cpp
// Function: ed::operator>>(std::istream&, ed::Estudiante&)
std::istream &operator>>(std::istream &i, ed::Estudiante &e){
  std::getline(i,e._nombre);

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

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x20d0
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20d0
movss 0x48(%r14), %xmm0
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20d0
movss 0x4c(%r14), %xmm0
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getCurrentItem() const
ed::Estudiante const & ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getCurrentItem() const{
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

	return getCurrent()->getItem();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x29a4
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x10(%rax)
leaq 0x3726(%rip), %rdi      # 0x60d1
leaq 0x372a(%rip), %rsi      # 0x60dc
leaq 0x3752(%rip), %rcx      # 0x610b
pushq $0x2c
popq %rdx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getPreviousItem() const
ed::Estudiante const & ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getPreviousItem() const{
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty() and !isFirstItem());
	#endif //NDEBUG

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x29f5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x29f5
movq 0x10(%rbx), %rax
movq 0x58(%rax), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x10(%rax)
leaq 0x3774(%rip), %rdi      # 0x6170
leaq 0x36d9(%rip), %rsi      # 0x60dc
leaq 0x3784(%rip), %rcx      # 0x618e
pushq $0x35
popq %rdx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getNextItem() const
ed::Estudiante const& ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::getNextItem() const{
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty() and !isLastItem());
	#endif //NDEBUG

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2a45
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
jne 0x2a45
movq 0x10(%rbx), %rax
movq 0x60(%rax), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x10(%rax)
leaq 0x37a8(%rip), %rdi      # 0x61f4
leaq 0x3689(%rip), %rsi      # 0x60dc
leaq 0x37b7(%rip), %rcx      # 0x6211
pushq $0x3e
popq %rdx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::isFirstItem() const
bool ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::isFirstItem() const{
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2a86
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3644(%rip), %rdi      # 0x60d1
leaq 0x3648(%rip), %rsi      # 0x60dc
leaq 0x37d8(%rip), %rcx      # 0x6273
pushq $0x47
popq %rdx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::isLastItem() const
bool ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::isLastItem() const{
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2ac9
movq 0x10(%rbx), %rax
cmpq $0x0, 0x60(%rax)
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3601(%rip), %rdi      # 0x60d1
leaq 0x3605(%rip), %rsi      # 0x60dc
leaq 0x37e6(%rip), %rcx      # 0x62c4
pushq $0x56
popq %rdx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoHead()
void ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoHead(){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

	setCurrent(getHead());

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2b14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x10(%rbx)
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x2b2d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x35b6(%rip), %rdi      # 0x60d1
leaq 0x35ba(%rip), %rsi      # 0x60dc
leaq 0x37eb(%rip), %rcx      # 0x6314
pushq $0x65
jmp 0x2b44
leaq 0x364c(%rip), %rdi      # 0x6180
leaq 0x35a1(%rip), %rsi      # 0x60dc
leaq 0x37d2(%rip), %rcx      # 0x6314
pushq $0x6c
popq %rdx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoLast()
void ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoLast(){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty());
	#endif //NDEBUG

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x2b7b
leaq 0x356e(%rip), %rdi      # 0x60d1
leaq 0x3572(%rip), %rsi      # 0x60dc
leaq 0x37eb(%rip), %rcx      # 0x635c
pushq $0x73
jmp 0x2bb3
movq %rbx, %rdi
callq *0x50(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq (%rbx), %rcx
testb %al, %al
je 0x2b75
movq %rbx, %rdi
callq *0x30(%rcx)
testb %al, %al
je 0x2b9c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3661(%rip), %rdi      # 0x6204
leaq 0x3532(%rip), %rsi      # 0x60dc
leaq 0x37ab(%rip), %rcx      # 0x635c
pushq $0x7c
popq %rdx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoPrevious()
void ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::gotoPrevious(){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty() and !isFirstItem());
	#endif //NDEBUG

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

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

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

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

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

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

				return true;
			}

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

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

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

			return true;
		}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2d32
pushq $0x38
popq %rcx
pushq $0x50
popq %r12
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax,%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movl %eax, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x276a
testb %r15b, %r15b
jne 0x2cf3
movq %r12, %rcx
testb %al, %al
je 0x2c83
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x276a
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2d34
leaq 0x3981(%rip), %rdi      # 0x665c
leaq 0x33fa(%rip), %rsi      # 0x60dc
leaq 0x374f(%rip), %rcx      # 0x6438
movl $0x9e, %edx
callq 0x2110
testb %al, %al
je 0x2d32
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x276a
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2d34
leaq 0x3942(%rip), %rdi      # 0x665c
leaq 0x33bb(%rip), %rsi      # 0x60dc
leaq 0x3710(%rip), %rcx      # 0x6438
movl $0xad, %edx
callq 0x2110
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::setCurrentItem(ed::Estudiante const&)
void ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::setCurrentItem(ed::Estudiante const & item){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(!isEmpty() and item.getNombre()==getCurrentItem().getNombre() and item.getApellidos()==getCurrentItem().getApellidos());
	#endif //NDEBUG

	Estudiante estudiante=getCurrentItem();

	getCurrent()->setItem(item);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x2eb2
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x2eb2
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x2eb2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x323e
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x2e93
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x2e93
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x2e93
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x2912
testb %al, %al
je 0x2e93
leaq -0x68(%rbp), %rdi
callq 0x3322
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36d3(%rip), %rdi      # 0x656d
leaq 0x323b(%rip), %rsi      # 0x60dc
leaq 0x3661(%rip), %rcx      # 0x6509
movl $0xc4, %edx
callq 0x2110
leaq 0x35d9(%rip), %rdi      # 0x6492
leaq 0x321c(%rip), %rsi      # 0x60dc
leaq 0x3642(%rip), %rcx      # 0x6509
movl $0xbb, %edx
callq 0x2110
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3322
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x336e
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/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 0x316c
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 0x30e6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x30e6
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x3157
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x310f
movq 0x10(%rbx), %rax
movq 0x60(%rax), %rcx
movq %rcx, 0x8(%rbx)
andq $0x0, 0x58(%rcx)
andq $0x0, 0x60(%rax)
movq %rcx, 0x10(%rbx)
jmp 0x3157
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x3139
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x10(%rbx), %rax
movq 0x60(%rax), %rcx
andq $0x0, 0x58(%rcx)
andq $0x0, 0x60(%rax)
jmp 0x3157
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 0x318b
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2f5e(%rip), %rdi      # 0x60d1
leaq 0x2f62(%rip), %rsi      # 0x60dc
leaq 0x354e(%rip), %rcx      # 0x66cf
movl $0x11b, %edx            # imm = 0x11B
callq 0x2110
leaq 0x3583(%rip), %rdi      # 0x6715
leaq 0x2f43(%rip), %rsi      # 0x60dc
leaq 0x352f(%rip), %rcx      # 0x66cf
movl $0x13e, %edx            # imm = 0x13E
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x38
popq %rcx
pushq $0x70
popq %r15
movq %rsi, %rdi
movq (%rdi), %rax
callq *(%rax,%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rbx, %rdi
movq %r15, %rcx
testb %al, %al
je 0x31c4
xorl %r15d, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
cmpl %eax, %r15d
jge 0x3207
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x68(%rcx)
incl %r15d
jmp 0x31df
movq 0x8(%rbx), %rax
cmpq 0x8(%r14), %rax
jne 0x321f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x34ff(%rip), %rdi      # 0x6725
leaq 0x2eaf(%rip), %rsi      # 0x60dc
leaq 0x350c(%rip), %rcx      # 0x6740
movl $0x151, %edx            # imm = 0x151
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/./estudiante.hpp
// Function: ed::Estudiante::Estudiante(ed::Estudiante const&)
Estudiante(const Estudiante & e){
		this->setNombre(e.getNombre());
		this->setApellidos(e.getApellidos());

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6a0d(%rip), %rax      # 0x9c60
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movq %rsi, %r14
movb %al, 0x38(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq -0x18(%rbp), %rsi
movss %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
leaq -0x14(%rbp), %rsi
movss %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x32e5
jmp 0x32e5
movq %rax, %r14
leaq 0x28(%rbx), %rdi
callq 0x2190
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2190
movq %r14, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x336e
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/./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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rdi, %r14
movss %xmm0, -0x28(%rbp)
movss %xmm1, -0x24(%rbp)
leaq 0x6790(%rip), %rax      # 0x9c60
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r15
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rbx, %rdi
callq 0x20e0
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x28(%rax)
movq (%r14), %rax
leaq -0x28(%rbp), %rsi
movq %r14, %rdi
callq *0x30(%rax)
movq (%r14), %rax
leaq -0x24(%rbp), %rsi
movq %r14, %rdi
callq *0x38(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2190
movq %r14, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x336e
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/asignatura.cpp
// Function: ed::Asignatura::getEstudiante(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ed::Estudiante const & ed::Asignatura::getEstudiante(std::string const &nombre, std::string const &apellidos){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(existeEstudiante(nombre,apellidos));
	#endif //NDEBUG

	return _lista.getCurrentItem();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x35e9
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2982
leaq 0x346a(%rip), %rdi      # 0x6a5a
leaq 0x32ad(%rip), %rsi      # 0x68a4
leaq 0x32b5(%rip), %rcx      # 0x68b3
pushq $0x12
popq %rdx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/asignatura.cpp
// Function: ed::Asignatura::getEstudiante(int)
ed::Estudiante const & ed::Asignatura::getEstudiante(int indice){
	#ifndef NDEBUG
		//Se comprueba la precondicion
		assert(indice<=getNumeroEstudiantes());
	#endif //NDEBUG

	int i;

	_lista.gotoHead();

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

	return _lista.getCurrentItem();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
cmpl %r14d, %eax
jl 0x3659
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x2ae6
xorl %r15d, %r15d
testl %r14d, %r14d
cmovgl %r14d, %r15d
subl $0x1, %r15d
jb 0x3647
movq %rbx, %rdi
callq 0x2c0c
jmp 0x3637
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2982
leaq 0x32b9(%rip), %rdi      # 0x6919
leaq 0x323d(%rip), %rsi      # 0x68a4
leaq 0x32ca(%rip), %rcx      # 0x6938
pushq $0x1b
popq %rdx
callq 0x2110