LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::LoadData::FindDivisionPlace(char const*, long const*, long, long)
static int64_t FindDivisionPlace(const char* buffer, const int64_t* token_arr, int64_t start, int64_t last)
		{
			for (int64_t a = last; a >= start; --a) {
				int64_t len = Utility::GetLength(token_arr[a]);
				int64_t val = Utility::GetType(token_arr[a]);


				if (len == 1 && (-1 != Utility::Equal(TYPE_RIGHT, val))) { // right
					return a;
				}

				bool pass = false;
				if (len == 1 && (-1 != Utility::Equal(TYPE_LEFT, val))) { // left
					return a;
				}
				else if (len == 1 && -1 != Utility::Equal(TYPE_ASSIGN, val)) { // assignment
					//
					pass = true;
				}

				if (a < last && pass == false) {
					int64_t len = Utility::GetLength(token_arr[a + 1]);
					int64_t val = Utility::GetType(token_arr[a + 1]);

					if (!(len == 1 && -1 != Utility::Equal(TYPE_ASSIGN, val))) // assignment
					{ // NOT
						return a;
					}
				}
			}
			return -1;
		}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x38(%rsp), %rax
jl 0xa1d1
movq 0x40(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xfe50
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11c90
movq %rax, 0x18(%rsp)
cmpq $0x1, 0x20(%rsp)
jne 0xa0e3
movq 0x18(%rsp), %rsi
movl $0x2, %edi
callq 0x11cb0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0xa0e3
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xa1da
movb $0x0, 0x17(%rsp)
cmpq $0x1, 0x20(%rsp)
jne 0xa119
movq 0x18(%rsp), %rsi
movl $0x1, %edi
callq 0x11cb0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0xa119
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xa1da
cmpq $0x1, 0x20(%rsp)
jne 0xa140
movq 0x18(%rsp), %rsi
movl $0x3, %edi
callq 0x11cb0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0xa140
movb $0x1, 0x17(%rsp)
jmp 0xa142
movq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rax
jge 0xa1bc
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xa1bc
movq 0x40(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0xfe50
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x11c90
movq %rax, (%rsp)
cmpq $0x1, 0x8(%rsp)
jne 0xa1ae
movq (%rsp), %rsi
movl $0x3, %edi
callq 0x11cb0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0xa1ba
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xa1da
jmp 0xa1bc
jmp 0xa1be
movq 0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xa072
movq $-0x1, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::InFileReserver::Scan2(char*, unsigned long, int, char*&, unsigned long*, long*&, unsigned long*, bool)
static std::pair<bool, int> Scan2(char* str, size_t len, int thr_num,
			char*& _buffer, size_t* _buffer_len, int64_t*& _token_arr, size_t* _token_arr_len, bool use_simd)
		{
			if (str == nullptr) {
				return { false, 0 };
			}

			std::string temp;
			char* buffer = str;
			size_t file_length;

			{
				size_t length = len;

				Utility::BomType x = Utility::ReadBom(str, length);

				//	clau_parser::Out << "length " << length << "\n";
				if (x == Utility::BomType::UTF_8) {
					length = length - 3;
				}

				file_length = length;

				buffer[file_length] = '\0';

				{
					int64_t* token_arr;
					size_t token_arr_size;

					if (thr_num == 1) {
						Scanning(buffer, file_length, token_arr, token_arr_size);
					}
					else {
						ScanningNew(buffer, file_length, thr_num, token_arr, token_arr_size, use_simd);
					}

					_buffer = buffer;
					_token_arr = token_arr;
					*_token_arr_len = token_arr_size;
					*_buffer_len = file_length;
				}
			}

			return{ true, 1 };
		}

// Assembly:
subq $0xb8, %rsp
movb 0xc8(%rsp), %al
movq 0xc0(%rsp), %r10
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movl %edx, 0x9c(%rsp)
movq %rcx, 0x90(%rsp)
movq %r8, 0x88(%rsp)
movq %r9, 0x80(%rsp)
andb $0x1, %al
movb %al, 0x7f(%rsp)
cmpq $0x0, 0xa8(%rsp)
jne 0xccef
movb $0x0, 0x7e(%rsp)
movl $0x0, 0x78(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0x7e(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0xce60
jmp 0xce44
leaq 0x58(%rsp), %rdi
callq 0x3350
movq 0xa8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x11290
movl %eax, 0xc(%rsp)
jmp 0xcd2b
movl 0xc(%rsp), %eax
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0xcd67
movq 0x40(%rsp), %rax
subq $0x3, %rax
movq %rax, 0x40(%rsp)
jmp 0xcd67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3160
jmp 0xce54
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x1, 0x9c(%rsp)
jne 0xcda6
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0xcf80
jmp 0xcda4
jmp 0xcdd4
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x9c(%rsp), %edx
movzbl 0x7f(%rsp), %r9d
andl $0x1, %r9d
leaq 0x20(%rsp), %rcx
leaq 0x18(%rsp), %r8
callq 0xd630
jmp 0xcdd2
jmp 0xcdd4
movq 0x50(%rsp), %rcx
movq 0x90(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x80(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0xc0(%rsp), %rax
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq 0x88(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x17(%rsp)
movl $0x1, 0x10(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0x17(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0xce60
jmp 0xce3a
leaq 0x58(%rsp), %rdi
callq 0x3160
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x33d0
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
leaq 0x23(%rsp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x3140
leaq 0x23(%rsp), %rdi
movq 0x28(%rsp), %rcx
movl $0x1, %esi
movl $0x5, %edx
callq 0x3370
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
jne 0xcef5
movq 0x28(%rsp), %rdi
callq 0x3080
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x32b0
movl $0x1, 0x34(%rsp)
jmp 0xcf70
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3140
leaq 0x23(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xe7c0
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jne 0xcf49
movq 0x28(%rsp), %rdi
callq 0x3080
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x32b0
movl $0x1, 0x34(%rsp)
jmp 0xcf70
movq 0x28(%rsp), %rdi
callq 0x3080
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
shlq $0x0, %rsi
xorl %edx, %edx
callq 0x32b0
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0x33(%rsp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x3140
cmpq $0x5, 0x40(%rsp)
jae 0xe7f7
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
jmp 0xe802
movl $0x5, %eax
movq %rax, (%rsp)
jmp 0xe802
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x33(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x31c0
movq $0x0, 0x20(%rsp)
cmpq $0x1, 0x20(%rsp)
jae 0xe8ef
movq 0x20(%rsp), %rcx
leaq 0xddb0(%rip), %rax      # 0x1c5f0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpq 0x28(%rsp), %rax
jbe 0xe85d
jmp 0xe8dc
movb $0x1, 0xf(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jae 0xe8b0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movsbl 0x8(%rax,%rcx), %eax
movq 0x18(%rsp), %rcx
movsbl 0x33(%rsp,%rcx), %ecx
cmpl %ecx, %eax
jne 0xe899
jmp 0xe8a0
movb $0x0, 0xf(%rsp)
jmp 0xe8b0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xe86b
testb $0x1, 0xf(%rsp)
jne 0xe8b9
jmp 0xe8dc
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl %eax, 0x54(%rsp)
jmp 0xe8f7
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xe828
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
// File: ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Utility::Get(long, long, char)
static int64_t Get(int64_t position, int64_t length, char ch) {
			int64_t x = (position << 32) + (length << 3) + 0;

			if (length != 1) {
				return x;
			}

			x += 2 * (LoadDataOption::Left == ch ? 1 : 0);
			x += 4 * (LoadDataOption::Right == ch ? 1 : 0);
			x += 6 * (LoadDataOption::Assignment == ch ? 1 : 0);

			/*
			if (LoadDataOption::Left == ch) {
				x += 2; // 010
			}
			else if (LoadDataOption::Right == ch) {
				x += 4; // 100
			}
			else if (LoadDataOption::Assignment == ch) {
				x += 6;
			}
			*/
			return x;
		}

// Assembly:
movb %dl, %al
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movb %al, -0x19(%rsp)
movq -0x10(%rsp), %rax
shlq $0x20, %rax
movq -0x18(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x0, %rax
movq %rax, -0x28(%rsp)
cmpq $0x1, -0x18(%rsp)
je 0xe942
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xe9ba
movsbl -0x19(%rsp), %esi
movl $0x7b, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
shll %eax
cltq
addq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movsbl -0x19(%rsp), %esi
movl $0x7d, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
shll $0x2, %eax
cltq
addq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movsbl -0x19(%rsp), %esi
movl $0x3d, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
imull $0x6, %eax, %eax
cltq
addq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Utility::isWhitespace(char)
static inline bool isWhitespace(const char ch)
		{
			switch (ch)
			{
			case ' ':
			case '\t':
			case '\r':
			case '\n':
			case '\v':
			case '\f':
				return true;
				break;
			}
			return false;
		}

// Assembly:
movb %dil, %al
movb %al, -0x2(%rsp)
movsbl -0x2(%rsp), %eax
movl %eax, -0x8(%rsp)
addl $-0x9, %eax
subl $0x5, %eax
jb 0xe9e5
jmp 0xe9da
movl -0x8(%rsp), %eax
subl $0x20, %eax
jne 0xe9ec
jmp 0xe9e5
movb $0x1, -0x1(%rsp)
jmp 0xe9f1
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax,%rax)
// File: 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:
movb %sil, %al
movq %rdi, -0x8(%rsp)
movb %al, -0x9(%rsp)
movq $0x1, -0x18(%rsp)
movq -0x8(%rsp), %rax
shlq $0x20, %rax
movq -0x18(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x0, %rax
movq %rax, -0x20(%rsp)
movsbl -0x9(%rsp), %esi
movl $0x7b, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
shll %eax
cltq
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movsbl -0x9(%rsp), %esi
movl $0x7d, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
shll $0x2, %eax
cltq
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movsbl -0x9(%rsp), %esi
movl $0x3d, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
imull $0x6, %eax, %eax
cltq
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
retq
nopw (%rax,%rax)
// File: 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 $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
leaq 0x2b(%rsp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x3140
movq $0x5, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5c10
movq (%rax), %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpq 0x20(%rsp), %rax
jne 0x112e2
movl $0x1, 0x44(%rsp)
jmp 0x11324
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3140
leaq 0x2b(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xe7c0
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jne 0x1131c
movl $0x1, 0x44(%rsp)
jmp 0x11324
movl 0x4(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl $0xb0, %edi
callq 0x3230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0x14ff0
jmp 0x141d8
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rdi, 0x28(%rax)
addq $0x30, %rdi
movl $0x2, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x6110
movq (%rsp), %rdi
addq $0x60, %rdi
leaq 0x20(%rsp), %rsi
callq 0x5530
movq (%rsp), %rax
movb $0x0, 0xa9(%rax)
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0xb0, %esi
callq 0x3240
movq 0x18(%rsp), %rdi
callq 0x33d0
nop
// File: ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::GetLastUserTypeItemRef(clau_parser::UserType*&)
bool GetLastUserTypeItemRef(UserType*& ref) {
			if (userTypeList.empty() == false) {
				ref = userTypeList.back();
				return true;
			}
			return false;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x60, %rdi
callq 0x8750
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1429b
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x5f80
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
jmp 0x142a0
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3140
leaq 0x28(%rsp), %rdi
callq 0x7b30
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
leaq 0x28(%rsp), %rsi
callq 0x7a50
leaq 0x28(%rsp), %rdi
callq 0x8270
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3140
leaq 0x10(%rsp), %rdi
callq 0x7b40
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x10(%rsp), %rsi
callq 0x7a10
leaq 0x10(%rsp), %rdi
callq 0x7f00
movq 0x8(%rsp), %rdi
callq 0x186b0
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
callq 0x156f0
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
callq 0x15710
movq 0x8(%rsp), %rax
movb $0x0, 0xa8(%rax)
movb $0x0, 0xa9(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xfe50
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11c90
movq %rax, 0x8(%rsp)
movl $0x1, %eax
cmpq 0x10(%rsp), %rax
jne 0x145eb
cmpq $0x1, 0x8(%rsp)
je 0x145e0
cmpq $0x2, 0x8(%rsp)
je 0x145e0
cmpq $0x3, 0x8(%rsp)
jne 0x145eb
movq 0x18(%rsp), %rax
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x58(%rsp), %rsi
callq 0x17bb0
movq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x17730
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
addq $0x28, %rsi
addq $0x28, %rdi
callq 0x32f0
movq (%rsp), %rax
movb 0x50(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x48(%rax)
leaq 0x8(%rsp), %rdi
callq 0x65c0
movq (%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x18(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x60, %rdi
callq 0x5b30
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x18758
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
movq 0x58(%rsp), %rsi
callq 0x7ad0
movq %rax, %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x18743
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
movq 0x58(%rsp), %rsi
callq 0x7ad0
movq (%rax), %rdi
callq 0x18840
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
movq 0x58(%rsp), %rsi
callq 0x7ad0
movq $0x0, (%rax)
jmp 0x18745
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x186cc
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
callq 0x189e0
leaq 0x40(%rsp), %rdi
callq 0x7b30
movq $0x0, 0x38(%rsp)
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x30, %rdi
callq 0x7410
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x18800
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq 0x38(%rsp), %rsi
callq 0xc090
cmpl $0x1, (%rax)
jne 0x187eb
movl $0x1, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x34(%rsp), %rsi
callq 0x6110
jmp 0x187cf
jmp 0x187eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8270
jmp 0x1882e
jmp 0x187ed
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x18779
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
leaq 0x40(%rsp), %rsi
callq 0x7a50
movq 0x18(%rsp), %rax
movb $0x0, 0xa9(%rax)
leaq 0x40(%rsp), %rdi
callq 0x8270
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x33d0
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x18a00
movq 0x80(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x18a40
jmp 0x1886d
leaq 0x68(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x18a10
jmp 0x1887e
jmp 0x18880
leaq 0x68(%rsp), %rdi
callq 0x18a90
xorb $-0x1, %al
testb $0x1, %al
jne 0x18895
jmp 0x189b7
leaq 0x68(%rsp), %rdi
callq 0x18ae0
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x18ae0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq 0x10(%rcx), %rax
jb 0x18963
leaq 0x68(%rsp), %rdi
callq 0x18ae0
movq (%rax), %rdi
addq $0x60, %rdi
callq 0x189e0
leaq 0x68(%rsp), %rdi
callq 0x18ae0
cmpq $0x0, (%rax)
je 0x1892c
leaq 0x68(%rsp), %rdi
callq 0x18ae0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1890d
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1892c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x18b40
jmp 0x189c9
leaq 0x68(%rsp), %rdi
callq 0x18b20
leaq 0x68(%rsp), %rdi
callq 0x18a90
testb $0x1, %al
jne 0x18946
jmp 0x18948
jmp 0x189b7
leaq 0x68(%rsp), %rdi
callq 0x18ae0
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x18880
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x18ae0
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x18ae0
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0x7910
movq (%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x18a40
jmp 0x189a1
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x18a10
jmp 0x189b2
jmp 0x18880
leaq 0x68(%rsp), %rdi
callq 0x18b40
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rsi
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x7a50
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x7a10
movq 0x10(%rsp), %rax
movb $0x0, 0xa8(%rax)
movb $0x0, 0xa9(%rax)
addq $0x60, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
callq 0x5b30
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x13f40
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
callq 0x5b30
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1ae99
movq 0x10(%rsp), %rax
addq $0x60, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
movq 0x20(%rsp), %rsi
callq 0x7ad0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x142b0
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
movq 0x20(%rsp), %rsi
callq 0x7ad0
movq 0x10(%rsp), %rdi
movq $0x0, (%rax)
addq $0x60, %rdi
callq 0x5f80
movq 0x10(%rsp), %rcx
movq (%rax), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1ae01
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
callq 0x189e0
movq 0x10(%rsp), %rdi
addq $0x78, %rdi
callq 0x156f0
movq 0x10(%rsp), %rdi
addq $0x90, %rdi
callq 0x15710
movq 0x28(%rsp), %rdi
addq $0x78, %rdi
callq 0x156f0
movq 0x28(%rsp), %rdi
addq $0x90, %rdi
callq 0x15710
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3140
leaq 0x28(%rsp), %rdi
callq 0x7b30
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
leaq 0x28(%rsp), %rsi
callq 0x7a50
leaq 0x28(%rsp), %rdi
callq 0x8270
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3140
leaq 0x10(%rsp), %rdi
callq 0x7b40
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x10(%rsp), %rsi
callq 0x7a10
leaq 0x10(%rsp), %rdi
callq 0x7f00
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
callq 0x156f0
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
callq 0x15710
movq 0x8(%rsp), %rdi
movb $0x0, 0xa8(%rdi)
movb $0x0, 0xa9(%rdi)
callq 0x186b0
addq $0x48, %rsp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0xca95(%rip), %rdi      # 0xffd0
leaq 0x7ace(%rip), %rsi      # 0xb010
callq 0x31a0
movq %rax, %rdi
leaq 0x7ac7(%rip), %rsi      # 0xb018
callq 0x31a0
movq %rax, %rdi
leaq 0x7ace(%rip), %rsi      # 0xb02e
callq 0x31a0
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq 0xca6c(%rip), %rdi      # 0xffe0
callq 0x3070
movq 0xca50(%rip), %rdi      # 0xffd0
leaq 0x7a89(%rip), %rsi      # 0xb010
callq 0x31a0
movq %rax, %rdi
leaq 0x7a9d(%rip), %rsi      # 0xb033
callq 0x31a0
movq %rax, %rdi
leaq 0x7a89(%rip), %rsi      # 0xb02e
callq 0x31a0
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq 0xca27(%rip), %rdi      # 0xffe0
callq 0x3070
movq 0xca0b(%rip), %rdi      # 0xffd0
leaq 0x7a44(%rip), %rsi      # 0xb010
callq 0x31a0
movq %rax, %rdi
leaq 0x7a72(%rip), %rsi      # 0xb04d
callq 0x31a0
movq %rax, %rdi
leaq 0x7a44(%rip), %rsi      # 0xb02e
callq 0x31a0
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
movq 0xc9e2(%rip), %rdi      # 0xffe0
callq 0x3080
movq 0xc9c6(%rip), %rdi      # 0xffd0
leaq 0x79ff(%rip), %rsi      # 0xb010
callq 0x31a0
movq %rax, %rdi
leaq 0x7a4c(%rip), %rsi      # 0xb06c
callq 0x31a0
movq %rax, %rdi
leaq 0x79ff(%rip), %rsi      # 0xb02e
callq 0x31a0
movq -0x10(%rbp), %rsi
addq $0x4c, %rsi
movq 0xc99d(%rip), %rdi      # 0xffe0
callq 0x3080
movq 0xc991(%rip), %rdi      # 0xffe0
callq 0x32d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xc955(%rip), %rdi      # 0xffd0
leaq 0x7a0b(%rip), %rsi      # 0xb08d
callq 0x31a0
movq %rax, %rdi
leaq 0x7a04(%rip), %rsi      # 0xb095
callq 0x31a0
movq -0x18(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq (%rdi), %rax
callq *(%rax)
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3180
movq %rax, %rdi
leaq 0x7975(%rip), %rsi      # 0xb02e
callq 0x31a0
movq %rax, %rdi
movq 0xc8f8(%rip), %rsi      # 0xffc0
callq 0x31c0
movq 0xc8fc(%rip), %rdi      # 0xffd0
leaq 0x79b2(%rip), %rsi      # 0xb08d
callq 0x31a0
movq %rax, %rdi
leaq 0x79b3(%rip), %rsi      # 0xb09d
callq 0x31a0
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3180
movq %rax, %rdi
leaq 0x791b(%rip), %rsi      # 0xb02e
callq 0x31a0
movq %rax, %rdi
movq 0xc89e(%rip), %rsi      # 0xffc0
callq 0x31c0
movq 0xc8a2(%rip), %rdi      # 0xffd0
leaq 0x7958(%rip), %rsi      # 0xb08d
callq 0x31a0
movq %rax, %rdi
leaq 0x7964(%rip), %rsi      # 0xb0a8
callq 0x31a0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
callq 0x3160
movq %rax, %rdi
leaq 0x78c4(%rip), %rsi      # 0xb02e
callq 0x31a0
movq %rax, %rdi
movq 0xc847(%rip), %rsi      # 0xffc0
callq 0x31c0
movq 0xc84b(%rip), %rdi      # 0xffd0
leaq 0x7901(%rip), %rsi      # 0xb08d
callq 0x31a0
movq %rax, %rdi
leaq 0x791e(%rip), %rsi      # 0xb0b9
callq 0x31a0
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x20(%rbp), %rdi
callq 0x3160
movq %rax, %rdi
leaq 0x786d(%rip), %rsi      # 0xb02e
callq 0x31a0
movq %rax, %rdi
movq 0xc7f0(%rip), %rsi      # 0xffc0
callq 0x31c0
movq 0xc7f4(%rip), %rdi      # 0xffd0
leaq 0x78aa(%rip), %rsi      # 0xb08d
callq 0x31a0
movq %rax, %rdi
leaq 0x78db(%rip), %rsi      # 0xb0cd
callq 0x31a0
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x3b10
movq -0x10(%rbp), %rdi
callq 0x3160
movq %rax, %rdi
leaq 0x7817(%rip), %rsi      # 0xb02e
callq 0x31a0
movq %rax, %rdi
movq 0xc79a(%rip), %rsi      # 0xffc0
callq 0x31c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/estudiante.cpp
// Function: ed::Estudiante::operator=(ed::Estudiante const&)
ed::Estudiante &ed::Estudiante::operator=(const ed::Estudiante &e){
	// Se comprueba que no sean el mismo objeto
	if (this != &e){
		this->setNombre(e.getNombre());
		this->setApellidos(e.getApellidos());

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

    // Se devuelve el objeto actual
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x10(%rbp), %rax
je 0x38c5
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movss %xmm0, -0x14(%rbp)
movq (%rdi), %rax
leaq -0x14(%rbp), %rsi
callq *0x30(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x20(%rbp), %rdi
movss %xmm0, -0x18(%rbp)
movq (%rdi), %rax
leaq -0x18(%rbp), %rsi
callq *0x38(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3bc0
testb $0x1, %al
jne 0x398e
jmp 0x3994
movb $0x1, -0x1(%rbp)
jmp 0x39f0
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3b40
testb $0x1, %al
jne 0x39be
jmp 0x39ec
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3bc0
testb $0x1, %al
jne 0x39e6
jmp 0x39ec
movb $0x1, -0x1(%rbp)
jmp 0x39f0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x3070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x3070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
callq 0x3080
movq -0x8(%rbp), %rdi
callq 0x32d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4c, %rsi
callq 0x3080
movq -0x8(%rbp), %rdi
callq 0x32d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x3180
movq %rax, %rdi
movq 0xc525(%rip), %rsi      # 0xffc0
callq 0x31c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x3180
movq %rax, %rdi
movq 0xc505(%rip), %rsi      # 0xffc0
callq 0x31c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movss 0x48(%rax), %xmm0
callq 0x3160
movq %rax, %rdi
movq 0xc4e4(%rip), %rsi      # 0xffc0
callq 0x31c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movss 0x4c(%rax), %xmm0
callq 0x3160
movq %rax, %rdi
movq 0xc4c3(%rip), %rsi      # 0xffc0
callq 0x31c0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::isEmpty() const
bool ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::isEmpty() const{
	if(getHead()==NULL){ //La asignatura esta vacia
		return true;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4d70
cmpq $0x0, %rax
jne 0x3c61
movb $0x1, -0x1(%rbp)
jmp 0x3c65
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-listas-doblemente-enlazadas-ordenadas/listaDoblementeEnlazadaOrdenadaEstudiantes.cpp
// Function: ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::nItems() const
int ed::ListaDoblementeEnlazadaOrdenadaEstudiantes::nItems() const{
	int items=0;
	ed::NodoDoblementeEnlazadoEstudiante *cursor; //Creamos un cursor auxiliar para no modificar nada de la lista

	cursor=getHead(); //Empezaremos el conteo desde la cabeza

	while(cursor!=NULL){
		cursor=cursor->getNext();

		items++;
	}

	delete cursor; //Destruimos el cursor auxiliar

	return items;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, -0xc(%rbp)
callq 0x4d70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3caf
movq -0x18(%rbp), %rdi
callq 0x4d90
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3c90
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3cc7
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
callq *(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x3d64
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x3d6d
jmp 0x3d6f
jmp 0x3d8e
leaq 0x7402(%rip), %rdi      # 0xb178
leaq 0x7367(%rip), %rsi      # 0xb0e4
movl $0x35, %edx
leaq 0x740d(%rip), %rcx      # 0xb196
callq 0x3140
movq -0x18(%rbp), %rdi
callq 0x4db0
movq %rax, %rdi
callq 0x4dd0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
callq *(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x3de4
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x3ded
jmp 0x3def
jmp 0x3e0e
leaq 0x7406(%rip), %rdi      # 0xb1fc
leaq 0x72e7(%rip), %rsi      # 0xb0e4
movl $0x3e, %edx
leaq 0x7410(%rip), %rcx      # 0xb219
callq 0x3140
movq -0x18(%rbp), %rdi
callq 0x4db0
movq %rax, %rdi
callq 0x4d90
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
callq *(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x3e51
jmp 0x3e53
jmp 0x3e72
leaq 0x727f(%rip), %rdi      # 0xb0d9
leaq 0x7283(%rip), %rsi      # 0xb0e4
movl $0x47, %edx
leaq 0x740e(%rip), %rcx      # 0xb27b
callq 0x3140
movq -0x18(%rbp), %rdi
callq 0x4db0
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x4d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x3e9a
movb $0x1, -0x1(%rbp)
jmp 0x3e9e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
callq *(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x3ed1
jmp 0x3ed3
jmp 0x3ef2
leaq 0x71ff(%rip), %rdi      # 0xb0d9
leaq 0x7203(%rip), %rsi      # 0xb0e4
movl $0x56, %edx
leaq 0x73df(%rip), %rcx      # 0xb2cc
callq 0x3140
movq -0x18(%rbp), %rdi
callq 0x4db0
movq %rax, %rdi
callq 0x4d90
cmpq $0x0, %rax
jne 0x3f0f
movb $0x1, -0x1(%rbp)
jmp 0x3f13
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rax
callq *(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x3f41
jmp 0x3f43
jmp 0x3f62
leaq 0x718f(%rip), %rdi      # 0xb0d9
leaq 0x7193(%rip), %rsi      # 0xb0e4
movl $0x65, %edx
leaq 0x73bf(%rip), %rcx      # 0xb31c
callq 0x3140
movq -0x10(%rbp), %rdi
callq 0x4d70
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x4df0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x3f87
jmp 0x3f89
jmp 0x3fa8
leaq 0x71f8(%rip), %rdi      # 0xb188
leaq 0x714d(%rip), %rsi      # 0xb0e4
movl $0x6c, %edx
leaq 0x7379(%rip), %rcx      # 0xb31c
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rax
callq *(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x3fd1
jmp 0x3fd3
jmp 0x3ff2
leaq 0x70ff(%rip), %rdi      # 0xb0d9
leaq 0x7103(%rip), %rsi      # 0xb0e4
movl $0x73, %edx
leaq 0x7377(%rip), %rcx      # 0xb364
callq 0x3140
jmp 0x3ff4
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x4006
jmp 0x4012
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x3ff4
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x4022
jmp 0x4024
jmp 0x4043
leaq 0x71e1(%rip), %rdi      # 0xb20c
leaq 0x70b2(%rip), %rsi      # 0xb0e4
movl $0x7c, %edx
leaq 0x7326(%rip), %rcx      # 0xb364
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
callq *(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x4084
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x408d
jmp 0x408f
jmp 0x40ae
leaq 0x70e2(%rip), %rdi      # 0xb178
leaq 0x7047(%rip), %rsi      # 0xb0e4
movl $0x83, %edx
leaq 0x7303(%rip), %rcx      # 0xb3ac
callq 0x3140
movq -0x18(%rbp), %rdi
callq 0x4db0
movq %rax, %rdi
callq 0x4dd0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x4df0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)