LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mattn[P]wandbox-run/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::parser::expect(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::token_type) const
void expect(typename lexer::token_type t) const
        {
            if (t != last_token)
            {
                std::string error_msg = "parse error - unexpected ";
                error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
                              "'") :
                              lexer::token_type_name(last_token));
                error_msg += "; expected " + lexer::token_type_name(t);
                JSON_THROW(std::invalid_argument(error_msg));
            }
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
cmpl %esi, 0x28(%rdi)
jne 0x17b2e
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %esi, %ebx
movq %rdi, %r14
leaq 0xb2f66(%rip), %rsi     # 0xcaaa0
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x16ce0
movl 0x28(%r14), %ebp
cmpl $0xe, %ebp
jne 0x17b93
addq $0x30, %r14
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x191f8
leaq 0xb310d(%rip), %rsi     # 0xcac75
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x191d3
leaq 0xb30f4(%rip), %rdx     # 0xcac75
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
callq 0x191b4
jmp 0x17b9d
movq %rsp, %rdi
movl %ebp, %esi
callq 0x1923c
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x998b0
movq %rsp, %rdi
callq 0x981a0
cmpl $0xe, %ebp
jne 0x17bce
leaq 0x80(%rsp), %rdi
callq 0x981a0
leaq 0x60(%rsp), %rdi
callq 0x981a0
leaq 0x40(%rsp), %rdi
movl %ebx, %esi
callq 0x1923c
leaq 0xb38f8(%rip), %rsi     # 0xcb4d9
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
callq 0x191d3
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x998b0
movq %rsp, %rdi
callq 0x981a0
leaq 0x40(%rsp), %rdi
callq 0x981a0
pushq $0x10
popq %rdi
callq 0x1b570
movq %rax, %r14
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x4cfa0
leaq 0xee27c(%rip), %rsi     # 0x105ea8
leaq 0xd2bd(%rip), %rdx      # 0x24ef0
movq %r14, %rdi
callq 0x1c5c0
jmp 0x17c75
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b5d0
jmp 0x17c99
movq %rax, %rbx
movq %rsp, %rdi
callq 0x981a0
jmp 0x17c5a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x17c94
jmp 0x17c75
movq %rax, %rbx
jmp 0x17c8f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x981a0
jmp 0x17c7d
movq %rax, %rbx
jmp 0x17c99
movq %rax, %rbx
cmpl $0xe, %ebp
jne 0x17c99
leaq 0x80(%rsp), %rdi
callq 0x981a0
leaq 0x60(%rsp), %rdi
callq 0x981a0
leaq 0x20(%rsp), %rdi
callq 0x981a0
movq %rbx, %rdi
callq 0xc6e00
nop
// File: /workspace/github_cpp_makefile_star2_O2/mattn[P]wandbox-run/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::parser::unexpect(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::token_type) const
void unexpect(typename lexer::token_type t) const
        {
            if (t == last_token)
            {
                std::string error_msg = "parse error - unexpected ";
                error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
                              "'") :
                              lexer::token_type_name(last_token));
                JSON_THROW(std::invalid_argument(error_msg));
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
cmpl %esi, 0x28(%rdi)
je 0x18974
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %r14
leaq 0xb2122(%rip), %rsi     # 0xcaaa0
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x16ce0
movl 0x28(%r14), %ebx
cmpl $0xe, %ebx
jne 0x189d5
addq $0x30, %r14
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x191f8
leaq 0xb22c7(%rip), %rsi     # 0xcac75
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x191d3
leaq 0xb22b1(%rip), %rdx     # 0xcac75
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x191b4
jmp 0x189e1
leaq 0x8(%rsp), %rdi
movl %ebx, %esi
callq 0x1923c
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x998b0
leaq 0x8(%rsp), %rdi
callq 0x981a0
cmpl $0xe, %ebx
jne 0x18a13
leaq 0x48(%rsp), %rdi
callq 0x981a0
leaq 0x28(%rsp), %rdi
callq 0x981a0
pushq $0x10
popq %rdi
callq 0x1b570
movq %rax, %rbx
leaq 0x68(%rsp), %rsi
movq %rax, %rdi
callq 0x4cfa0
leaq 0xed476(%rip), %rsi     # 0x105ea8
leaq 0xc4b7(%rip), %rdx      # 0x24ef0
movq %rbx, %rdi
callq 0x1c5c0
jmp 0x18a64
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b5d0
jmp 0x18a85
movq %rax, %r14
jmp 0x18a7b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x981a0
jmp 0x18a6c
movq %rax, %r14
jmp 0x18a85
movq %rax, %r14
cmpl $0xe, %ebx
jne 0x18a85
leaq 0x48(%rsp), %rdi
callq 0x981a0
leaq 0x28(%rsp), %rdi
callq 0x981a0
leaq 0x68(%rsp), %rdi
callq 0x981a0
movq %r14, %rdi
callq 0xc6e00
nop
// File: /workspace/github_cpp_makefile_star2_O2/mattn[P]wandbox-run/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
reference operator[](const typename object_t::key_type& key)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_type = value_t::object;
            m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (is_object())
        {
            return m_value.object->operator[](key);
        }

        JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0x18dd0
movb $0x1, (%r14)
callq 0x19064
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x17a70
movb (%r14), %al
cmpb $0x1, %al
jne 0x18de8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x196d8
pushq $0x10
popq %rdi
callq 0x1b570
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1973e
leaq 0xb207d(%rip), %rsi     # 0xcae82
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x191d3
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4cf80
xorl %ebp, %ebp
leaq 0xed065(%rip), %rsi     # 0x105e90
leaq 0xc07e(%rip), %rdx      # 0x24eb0
movq %rbx, %rdi
callq 0x1c5c0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x981a0
jmp 0x18e4f
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x981a0
testb %bpl, %bpl
jne 0x18e61
jmp 0x18e69
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b5d0
movq %r14, %rdi
callq 0xc6e00
nop
// File: /workspace/github_cpp_makefile_star2_O2/mattn[P]wandbox-run/./json.hpp
// Function: bool nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::strtonum::parse<unsigned long>(unsigned long&, std::integral_constant<bool, true>) const
bool parse(T& value, /*is_integral=*/std::true_type) const
            {
                char* endptr = nullptr;
                errno = 0; // these are thread-local
                const auto x = parse_integral(&endptr, std::is_signed<T>());

                // called right overload?
                static_assert(std::is_signed<T>() == std::is_signed<decltype(x)>(), "");

                value = static_cast<T>(x);

                return (x == static_cast<decltype(x)>(value)) // x fits into destination T
                       and (x < 0) == (value < 0)             // preserved sign
                       //and ((x != 0) or is_integral())        // strto[u]ll did nto fail
                       and (errno == 0)                       // strto[u]ll did not overflow
                       and (m_start < m_end)                  // token was not empty
                       and (endptr == m_end);                 // parsed entire token exactly
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
andq $0x0, (%r15)
callq 0x13690
movq %rax, %r12
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19e1e
movq %rax, (%r14)
cmpl $0x0, (%r12)
jne 0x19e0f
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
jae 0x19e0f
cmpq %rax, (%rsp)
sete %al
jmp 0x19e11
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mattn[P]wandbox-run/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::operator==(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>> const&) const
bool operator==(const iter_impl& other) const
        {
            // if objects are not the same, the comparison is undefined
            if (m_object != other.m_object)
            {
                JSON_THROW(std::domain_error("cannot compare iterators of different containers"));
            }

            assert(m_object != nullptr);

            switch (m_object->m_type)
            {
                case basic_json::value_t::object:
                {
                    return (m_it.object_iterator == other.m_it.object_iterator);
                }

                case basic_json::value_t::array:
                {
                    return (m_it.array_iterator == other.m_it.array_iterator);
                }

                default:
                {
                    return (m_it.primitive_iterator == other.m_it.primitive_iterator);
                }
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x1a1bf
testq %rax, %rax
je 0x1a1ef
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x1a1a2
cmpl $0x1, %eax
jne 0x1a1ac
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x1a1b4
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x1a1b4
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x1b570
movq %rax, %rbx
leaq 0xb1612(%rip), %rsi     # 0xcb7e3
movq %rax, %rdi
callq 0x2f310
leaq 0xebcb0(%rip), %rsi     # 0x105e90
leaq 0xacc9(%rip), %rdx      # 0x24eb0
movq %rbx, %rdi
callq 0x1c5c0
leaq 0xb12ef(%rip), %rdi     # 0xcb4e5
leaq 0xb0108(%rip), %rsi     # 0xca305
leaq 0xb1610(%rip), %rcx     # 0xcb814
movl $0x242c, %edx           # imm = 0x242C
callq 0x13130
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b5d0
movq %r14, %rdi
callq 0xc6e00
// File: /workspace/github_cpp_makefile_star2_O2/mattn[P]wandbox-run/./json.hpp
// Function: void nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::serializer::dump_integer<long, 0>(long)
void dump_integer(NumberType x)
        {
            // special case for "0"
            if (x == 0)
            {
                o.put('0');
                return;
            }

            const bool is_negative = x < 0;
            size_t i = 0;

            // spare 1 byte for '\0'
            while (x != 0 and i < number_buffer.size() - 1)
            {
                const auto digit = std::labs(static_cast<long>(x % 10));
                number_buffer[i++] = static_cast<char>('0' + digit);
                x /= 10;
            }

            // make sure the number has been processed completely
            assert(x == 0);

            if (is_negative)
            {
                // make sure there is capacity for the '-'
                assert(i < number_buffer.size() - 2);
                number_buffer[i++] = '-';
            }

            std::reverse(number_buffer.begin(), number_buffer.begin() + i);
            o.write(number_buffer.data(), static_cast<std::streamsize>(i));
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1ab51
leaq 0x8(%rbx), %r14
xorl %r15d, %r15d
pushq $0xa
popq %rcx
movq %rsi, %rax
testq %rax, %rax
je 0x1ab1e
cmpq $0x3f, %r15
je 0x1ab61
cqto
idivq %rcx
movq %rdx, %rdi
negq %rdi
cmovsq %rdx, %rdi
addb $0x30, %dil
movb %dil, 0x8(%rbx,%r15)
incq %r15
jmp 0x1aaf6
testq %rsi, %rsi
jns 0x1ab32
cmpq $0x3e, %r15
jae 0x1ab80
movb $0x2d, 0x8(%rbx,%r15)
incq %r15
leaq (%r14,%r15), %rsi
movq %r14, %rdi
callq 0x1ae2d
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x87610
movq (%rbx), %rdi
pushq $0x30
popq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x87490
leaq 0xb162e(%rip), %rdi     # 0xcc196
leaq 0xaf796(%rip), %rsi     # 0xca305
leaq 0xb1627(%rip), %rcx     # 0xcc19d
movl $0x19e0, %edx           # imm = 0x19E0
callq 0x13130
leaq 0xb1779(%rip), %rdi     # 0xcc300
leaq 0xaf777(%rip), %rsi     # 0xca305
leaq 0xb1608(%rip), %rcx     # 0xcc19d
movl $0x19e5, %edx           # imm = 0x19E5
callq 0x13130
nop
// File: /workspace/github_cpp_makefile_star2_O2/moya-lang[P]Allocator/Measure.cpp
// Function: void printTestStatus<PushFrontTest<std::forward_list<unsigned long, std::allocator<unsigned long>>>, PushFrontTest<std::forward_list<unsigned long, Moya::Allocator<unsigned long, 1024ul>>>>(char const*, PushFrontTest<std::forward_list<unsigned long, std::allocator<unsigned long>>>&, PushFrontTest<std::forward_list<unsigned long, Moya::Allocator<unsigned long, 1024ul>>>&)
void printTestStatus(const char *name, StlAllocatorContainer &stlContainer, MoyaAllocatorContainer &fastContainer)
{
    double stlRunTime = stlContainer.run();
    double moyaRunTime = fastContainer.run();

    std::cout << std::fixed;
    std::cout << name << " - Default STL Allocator : " << stlRunTime << " seconds." << std::endl;
    std::cout << name << " - Memory Pool Allocator : " << moyaRunTime << " seconds." << std::endl;
    std::cout << name << " - Gain : x" << stlRunTime / moyaRunTime << "." << std::endl;
    std::cout << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4446
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x44a6
movsd %xmm0, (%rsp)
movq 0x6a0c(%rip), %rbx      # 0x8fd0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl 0x18(%rbx,%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20e0
leaq 0x2a86(%rip), %rsi      # 0x5073
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2140
leaq 0x2a85(%rip), %r15      # 0x508f
movq %rax, %rdi
movq %r15, %rsi
callq 0x20e0
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20e0
leaq 0x2a6a(%rip), %rsi      # 0x5099
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x2140
movq %rax, %rdi
movq %r15, %rsi
callq 0x20e0
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20e0
leaq 0x2a4c(%rip), %rsi      # 0x50b5
movq %rax, %rdi
callq 0x20e0
movsd 0x8(%rsp), %xmm0
divsd (%rsp), %xmm0
movq %rax, %rdi
callq 0x2140
leaq 0x2a0c(%rip), %rsi      # 0x5097
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/moya-lang[P]Allocator/./Allocator.h
// Function: Moya::MemoryPool<std::_Fwd_list_node<unsigned long>, 1024ul>::~MemoryPool()
~MemoryPool()
        {
            while (firstBuffer) {
                Buffer *buffer = firstBuffer;
                firstBuffer = buffer->next;
                delete buffer;
            }
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2e14
movq 0x4000(%rdi), %rax
movq %rax, 0x8(%rbx)
movl $0x4008, %esi           # imm = 0x4008
callq 0x2100
jmp 0x2df4
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/moya-lang[P]Allocator/./Allocator.h
// Function: Moya::Allocator<std::_Fwd_list_node<unsigned long>, 1024ul>::allocate(unsigned long, void const*)
pointer allocate(size_type n, const void *hint = 0)
        {
#if defined(_WIN32) && defined(ENABLE_OLD_WIN32_SUPPORT)
            if (copyAllocator)
                return copyAllocator->allocate(n, hint);

            if (rebindAllocator)
                return rebindAllocator->allocate(n, hint);
#endif

            if (n != 1 || hint)
                throw std::bad_alloc();

            return MemoryPool<T, growSize>::allocate();
        }

// Assembly:
cmpq $0x1, %rsi
jne 0x2e6f
testq %rdx, %rdx
je 0x2e9c
pushq %rax
pushq $0x8
popq %rdi
callq 0x20a0
movq 0x6149(%rip), %rcx      # 0x8fc8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x614b(%rip), %rsi      # 0x8fd8
movq 0x6124(%rip), %rdx      # 0x8fb8
movq %rax, %rdi
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/moya-lang[P]Allocator/./Allocator.h
// Function: Moya::MemoryPool<std::_Fwd_list_node<unsigned long>, 1024ul>::allocate()
T *allocate()
        {
            if (firstFreeBlock) {
                Block *block = firstFreeBlock;
                firstFreeBlock = block->next;
                return reinterpret_cast<T *>(block);
            }

            if (bufferedBlocks >= growSize) {
                firstBuffer = new Buffer(firstBuffer);
                bufferedBlocks = 0;
            }

            return firstBuffer->getBlock(bufferedBlocks++);
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x2eb0
movq (%rax), %rcx
movq %rcx, (%rbx)
jmp 0x2eef
movq 0x10(%rbx), %rax
cmpq $0x3ff, %rax            # imm = 0x3FF
jbe 0x2edc
movl $0x4008, %edi           # imm = 0x4008
callq 0x20f0
movq %rax, %rcx
movq 0x8(%rbx), %rax
movq %rax, 0x4000(%rcx)
movq %rcx, 0x8(%rbx)
xorl %eax, %eax
jmp 0x2ee0
movq 0x8(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x10(%rbx)
shlq $0x4, %rax
addq %rcx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/moya-lang[P]Allocator/Measure.cpp
// Function: MapTest<std::map<unsigned long, unsigned long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, unsigned long>>>>::testIteration(unsigned long)
virtual void testIteration(size_t newSize)
    {
        size_t size = 0;

        for (; size < newSize; size++)
            this->container.insert(typename Container::value_type(size, size));

        while (size > newSize)
            this->container.erase(--size);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
cmpq %rbx, %r12
jae 0x3348
movq %r12, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x33e8
incq %r12
jmp 0x3329
leaq 0x8(%rsp), %r15
cmpq %rbx, %r12
jbe 0x336c
decq %r12
movq %r12, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x353e
movq 0x8(%rsp), %r12
jmp 0x334d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/moya-lang[P]Allocator/Measure.cpp
// Function: SetTest<std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>>>::testIteration(unsigned long)
virtual void testIteration(size_t newSize)
    {
        size_t size = 0;

        while (size < newSize)
            this->container.insert(size++);

        while (size > newSize)
            this->container.erase(--size);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
xorl %eax, %eax
leaq 0x10(%rsp), %r15
cmpq %rbx, %rax
jae 0x3bfd
leaq 0x1(%rax), %r12
movq %r12, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c9e
movq %r12, %rax
jmp 0x3bda
leaq 0x8(%rsp), %r15
cmpq %rbx, %rax
jbe 0x3c21
decq %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3df8
movq 0x8(%rsp), %rax
jmp 0x3c02
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/moya-lang[P]Allocator/Measure.cpp
// Function: PerformanceTest<std::forward_list<unsigned long, std::allocator<unsigned long>>>::run()
double run()
        {
            auto from = std::chrono::high_resolution_clock::now();

            for (size_t i = 0; i < numberOfIterations; i++)
                testIteration(randomNumberDistribution(randomNumberGenerator));

            auto to = std::chrono::high_resolution_clock::now();
            return std::chrono::duration_cast<std::chrono::duration<double>>(to - from).count();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x2030
movq %rax, %rbx
leaq 0x18(%r14), %r15
leaq 0x10(%r14), %r12
movl $0x400, %r13d           # imm = 0x400
subq $0x1, %r13
jb 0x4486
movq %r15, %rdi
movq %r12, %rsi
callq 0x4506
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
jmp 0x4468
callq 0x2030
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0xb6d(%rip), %xmm0      # 0x5008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/estudiante.cpp
// Function: ed::Estudiante::leerEstudiante()
void ed::Estudiante::leerEstudiante(){
	std::cout << IYELLOW << "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 << IYELLOW << "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 << IYELLOW << "Introduce la nota de teoría: " << RESET;
	std::cin >> this->_teoria;

	std::cout << IYELLOW << "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 0x8b5c(%rip), %r15      # 0xafd0
leaq 0x4b8d(%rip), %r12      # 0x7008
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
leaq 0x4b83(%rip), %rsi      # 0x7010
movq %rax, %rdi
callq 0x2160
leaq 0x5903(%rip), %r13      # 0x7d9f
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
leaq 0x8(%rbx), %rsi
movq 0x8b2e(%rip), %r14      # 0xafe0
movq %r14, %rdi
callq 0x2060
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
leaq 0x4b5a(%rip), %rsi      # 0x7026
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 0x4b43(%rip), %rsi      # 0x7040
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
leaq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x2260
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
leaq 0x4b31(%rip), %rsi      # 0x705f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
addq $0x4c, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2260
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-arboles-binarios-ordenados/estudiante.cpp
// Function: ed::Estudiante::escribirEstudiante() const
void ed::Estudiante::escribirEstudiante()const{
	std::cout << BBLUE << "Nombre: " << BLUE << this->getNombre() << RESET << std::endl;

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

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

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

	std::cout << BBLUE << "Nota final: " << BLUE << 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 0x8a52(%rip), %r14      # 0xafd0
leaq 0x4afb(%rip), %r15      # 0x7080
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x4af1(%rip), %rsi      # 0x7088
movq %rax, %rdi
callq 0x2160
leaq 0x4aeb(%rip), %r12      # 0x7091
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x2140
leaq 0x57d0(%rip), %rsi      # 0x7d9f
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r14, %r13
movq %r15, %rsi
callq 0x2160
leaq 0x4aa5(%rip), %rsi      # 0x7099
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x2140
movq %rax, %rdi
leaq 0x5777(%rip), %rsi      # 0x7d9f
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq %r13, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x4a5e(%rip), %rsi      # 0x70a5
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
leaq 0x5727(%rip), %rsi      # 0x7d9f
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq %r13, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x4a20(%rip), %rsi      # 0x70b7
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
leaq 0x56d7(%rip), %r14      # 0x7d9f
movq %r14, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq %r13, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x49e2(%rip), %rsi      # 0x70cc
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movss 0x48(%rbx), %xmm0
addss 0x4c(%rbx), %xmm0
mulss 0x48f5(%rip), %xmm0     # 0x7004
movq %rax, %rdi
callq 0x2120
movq %rax, %rdi
movq %r14, %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-arboles-binarios-ordenados/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());
	}

	//Postcondición
	#ifndef NDEBUG
		assert((*this)==e);
	#endif
	
	//Se devuelve el objeto actual
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x27ac
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x38(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
leaq -0x18(%rbp), %rsi
movss %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
leaq -0x14(%rbp), %rsi
movss %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27e4
testb %al, %al
je 0x27c7
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x490b(%rip), %rdi      # 0x70d9
leaq 0x490f(%rip), %rsi      # 0x70e4
leaq 0x4917(%rip), %rcx      # 0x70f3
pushq $0x4d
popq %rdx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/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 0x2260
movq %rbx, %rdi
callq 0x2240
addq $0x4c, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
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-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::liberarMemoria()
void ed::NodoEnlazadoArbolBinarioEstudiante::liberarMemoria(){
	if(hasLeftTree()){ //Liberamos la memoria del subárbol hijo izquierdo
		getLeftTree()->liberarMemoria();
	}
			
	if(hasRightTree()){ //Liberamos la memoria del subárbol hijo derecho
		getRightTree()->liberarMemoria();
	}
	
	//Borramos los atributos del nodo raíz
	delete _item;
	delete getLeftTree();
	delete getRightTree();
		
	_item=NULL;
	setLeftTree(NULL);
	setRightTree(NULL);
	setParent(NULL);
	
	//Postcondición
	#ifndef NDEBUG
		assert(isEmpty());
	#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x29ea
callq 0x29d8
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x29f8
callq 0x29d8
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2a07
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2a16
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0x2a29
movq (%rdi), %rax
callq *0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::nItems() const
int ed::NodoEnlazadoArbolBinarioEstudiante::nItems() const{
	int items=0;

	if(!isEmpty()){
		items++; //Sumamos el ítem del nodo raíz

		if(hasLeftTree()){
			items=items+getLeftTree()->nItems(); //Sumamos los ítems de su subárbol hijo izquierdo
		}

		if(hasRightTree()){
			items=items+getRightTree()->nItems(); //Sumamos los ítems de su subárbol hijo derecho
		}
	}

	return items;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
pushq $0x1
popq %r15
xorl %ebp, %ebp
cmpq $0x0, 0x8(%r14)
je 0x2a71
movq 0x10(%r14), %rdi
movl %r15d, %eax
testq %rdi, %rdi
je 0x2a62
callq 0x2a36
incl %eax
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x2a6f
addl %eax, %ebp
jmp 0x2a48
movl %eax, %ebx
addl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::exists(ed::Estudiante const&)
bool ed::NodoEnlazadoArbolBinarioEstudiante::exists(ed::Estudiante const &item){
	if(isEmpty()){
		return false; //Si el árbol está vacío, es imposible que exista el ítem
	}

	else{ //El árbol no está vacío
		if(getItem()==item){ //El nodo raíz contiene el ítem que buscamos
			return true;
		}

		else{ //El nodo raíz no contiene el ítem que buscamos
			if(item<getItem()){ //El ítem ha de encontrarse a la izquierda del árbol
				if(hasLeftTree()){
					return getLeftTree()->exists(item); //Buscamos el ítem en el subárbol hijo izquierdo
				}

				else{
					return false;
				}
			}

			else{ //El ítem ha de encontrarse a la derecha del árbol
				if(hasRightTree()){
					return getRightTree()->exists(item); //Buscamos el ítem en el subárbol hijo derecho
				}

				else{
					return false;
				}
			}
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%r14)
je 0x2ad0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x27e4
testb %al, %al
jne 0x2ad4
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x284c
testb %al, %al
je 0x2ac7
movq 0x10(%r14), %r14
jmp 0x2acb
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x2a8a
xorl %eax, %eax
jmp 0x2ad6
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(ed::Estudiante const&)
ed::Estudiante const &ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(ed::Estudiante const & item){
	//Precondición
	#ifndef NDEBUG
		assert(exists(item));
	#endif

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

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a80
testb %al, %al
je 0x2b37
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x27e4
movl %eax, %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %bpl, %bpl
jne 0x2b32
movq %rbx, %rdi
movq %rax, %rsi
callq 0x284c
xorb $0x1, %al
movzbl %al, %eax
movq 0x10(%r14,%rax,8), %r14
jmp 0x2ae8
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x47bc(%rip), %rdi      # 0x72fa
leaq 0x460b(%rip), %rsi      # 0x7150
leaq 0x462b(%rip), %rcx      # 0x7177
pushq $0x5f
popq %rdx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(int)
ed::Estudiante const &ed::NodoEnlazadoArbolBinarioEstudiante::getEstudiante(int indice){
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty() and indice<=nItems());
	#endif

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
pushq $-0x1
popq %rbp
cmpq $0x0, 0x8(%r15)
je 0x2bb5
movq %r15, %r14
movq %r15, %rdi
callq 0x2a36
cmpl %ebx, %eax
jl 0x2bb5
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x2b94
movq %r15, %rdi
callq 0x2a36
cmpl %ebx, %eax
je 0x2ba2
jg 0x2b63
notl %eax
jmp 0x2b9a
movl %ebp, %eax
testl %ebx, %ebx
je 0x2ba2
addl %eax, %ebx
movq 0x18(%r14), %r15
jmp 0x2b63
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x10(%rax)
leaq 0x461f(%rip), %rdi      # 0x71db
leaq 0x458d(%rip), %rsi      # 0x7150
leaq 0x4631(%rip), %rcx      # 0x71fb
pushq $0x74
popq %rdx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::getMinor() const
ed::Estudiante const &ed::NodoEnlazadoArbolBinarioEstudiante::getMinor() const{
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty());
	#endif

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

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

// Assembly:
pushq %rax
movq %rdi, %rax
cmpq $0x0, 0x8(%rax)
je 0x2bf0
movq %rax, %rdi
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x2bd6
movq (%rdi), %rax
popq %rcx
jmpq *0x10(%rax)
leaq 0x4655(%rip), %rdi      # 0x724c
leaq 0x4552(%rip), %rsi      # 0x7150
leaq 0x4652(%rip), %rcx      # 0x7257
movl $0x93, %edx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::setEstudiante(ed::Estudiante const&)
void ed::NodoEnlazadoArbolBinarioEstudiante::setEstudiante(ed::Estudiante const &item){
	//Precondición
	#ifndef NDEBUG
		assert(exists(item));
	#endif

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2a80
testb %al, %al
je 0x2c84
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x27e4
movq (%r14), %rcx
movq %r14, %rdi
testb %al, %al
je 0x2c49
movq %rbx, %rsi
callq *0x18(%rcx)
jmp 0x2c6d
callq *0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x284c
testb %al, %al
je 0x2c61
movq 0x10(%r14), %rdi
jmp 0x2c65
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x2c10
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a80
testb %al, %al
je 0x2ca3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x466f(%rip), %rdi      # 0x72fa
leaq 0x44be(%rip), %rsi      # 0x7150
leaq 0x460d(%rip), %rcx      # 0x72a6
movl $0xa2, %edx
callq 0x2110
leaq 0x4650(%rip), %rdi      # 0x72fa
leaq 0x449f(%rip), %rsi      # 0x7150
leaq 0x45ee(%rip), %rcx      # 0x72a6
movl $0xb3, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::inorder()
void ed::NodoEnlazadoArbolBinarioEstudiante::inorder(){
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty());
	#endif

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7fc4(%rip), %r14      # 0xafd0
cmpq $0x0, 0x8(%rbx)
je 0x304b
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3021
callq 0x2ffe
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %rax, %rdi
callq 0x2566
movq %r14, %rdi
callq 0x20d0
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x300c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x41fa(%rip), %rdi      # 0x724c
leaq 0x40f7(%rip), %rsi      # 0x7150
leaq 0x434a(%rip), %rcx      # 0x73aa
movl $0x166, %edx            # imm = 0x166
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::grabar(std::basic_ofstream<char, std::char_traits<char>>&)
void ed::NodoEnlazadoArbolBinarioEstudiante::grabar(std::ofstream &fichero){
	//Precondición
	#ifndef NDEBUG
		assert(!isEmpty());
	#endif

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%r14)
je 0x30b1
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x292a
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x30a0
movq %rbx, %rsi
callq 0x306a
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x3074
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4194(%rip), %rdi      # 0x724c
leaq 0x4091(%rip), %rsi      # 0x7150
leaq 0x431b(%rip), %rcx      # 0x73e1
movl $0x178, %edx            # imm = 0x178
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::~Estudiante()
~Estudiante(){
		this->setNombre("");
		this->setApellidos("");

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x7aff(%rip), %rax      # 0xaca8
movq %rax, (%rdi)
leaq 0x465e(%rip), %rsi      # 0x7811
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x20a0
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x30(%rax)
leaq 0x8(%rsp), %rdi
callq 0x2190
leaq 0x4630(%rip), %rsi      # 0x7811
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x20a0
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x38(%rax)
leaq 0x8(%rsp), %rdi
callq 0x2190
leaq 0x8(%rsp), %rsi
andl $0x0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
leaq 0x8(%rsp), %rsi
andl $0x0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
leaq 0x28(%rbx), %rdi
callq 0x2190
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2190
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
jmp 0x327c
jmp 0x3270
jmp 0x3270
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2190
jmp 0x3273
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2190
jmp 0x3273
jmp 0x3270
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 0x3298
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./nodoEnlazadoArbolBinarioEstudiante.hpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::setItem(ed::Estudiante const&)
inline void setItem(ed::Estudiante const & nuevoItem){
			//Si el ítem actual es nulo
			if (this->_item == NULL){
				//Se reserva memoria y se copia el nuevo ítem
				this->_item = new Estudiante(nuevoItem);
			}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x332a
movq %rbx, %rsi
callq 0x2738
jmp 0x3344
pushq $0x50
popq %rdi
callq 0x2170
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x30d0
movq %r15, 0x8(%r14)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x27e4
testb %al, %al
je 0x3362
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4155(%rip), %rdi      # 0x74be
leaq 0x40b6(%rip), %rsi      # 0x7426
leaq 0x415c(%rip), %rcx      # 0x74d3
movl $0x124, %edx            # imm = 0x124
callq 0x2110
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::setNombre(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void setNombre(const std::string & nombre){
		this->_nombre = nombre;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getNombre()==nombre);
		#endif
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x20e0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2990
testb %al, %al
je 0x340d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4114(%rip), %rdi      # 0x7528
leaq 0x4121(%rip), %rsi      # 0x753c
leaq 0x412b(%rip), %rcx      # 0x754d
movl $0xa4, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::setApellidos(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void setApellidos(const std::string & apellidos){
		this->_apellidos = apellidos;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getApellidos()==apellidos);
		#endif
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rdi
callq 0x20e0
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2990
testb %al, %al
je 0x345f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4123(%rip), %rdi      # 0x7589
leaq 0x40cf(%rip), %rsi      # 0x753c
leaq 0x412f(%rip), %rcx      # 0x75a3
movl $0xb6, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::setTeoria(float const&)
inline void setTeoria(const float & teoria){
		this->_teoria = teoria;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getTeoria()==teoria);
		#endif
	}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movss (%rsi), %xmm0
movss %xmm0, 0x48(%rdi)
movq (%rdi), %rax
callq *0x20(%rax)
ucomiss (%rbx), %xmm0
jne 0x349a
jp 0x349a
popq %rbx
retq
leaq 0x4141(%rip), %rdi      # 0x75e2
leaq 0x4094(%rip), %rsi      # 0x753c
leaq 0x4147(%rip), %rcx      # 0x75f6
movl $0xc8, %edx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/./estudiante.hpp
// Function: ed::Estudiante::setPractica(float const&)
inline void setPractica(const float & practica){
		this->_practica = practica;
		
		//Postcondición
		#ifndef NDEBUG
			assert(getPractica()==practica);
		#endif
	}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movss (%rsi), %xmm0
movss %xmm0, 0x4c(%rdi)
movq (%rdi), %rax
callq *0x28(%rax)
ucomiss (%rbx), %xmm0
jne 0x34d6
jp 0x34d6
popq %rbx
retq
leaq 0x414f(%rip), %rdi      # 0x762c
leaq 0x4058(%rip), %rsi      # 0x753c
leaq 0x4159(%rip), %rcx      # 0x7644
movl $0xda, %edx
callq 0x2110
nopl (%rax)