LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::detail::input_stream_adapter::get_character()
std::char_traits<char>::int_type get_character()
    {
        auto res = sb->sbumpc();
        // set eof manually, as we don't use the istream interface.
        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
        {
            is->clear(is->rdstate() | std::ios::eofbit);
        }
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x31e0
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x6be5
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x2, %esi
callq 0x34d0
jmp 0x6bde
nop
// File: /workspace/github_cpp_makefile_star2_O2/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>)
basic_json& operator=(basic_json other) noexcept (
        std::is_nothrow_move_constructible<value_t>::value&&
        std::is_nothrow_move_assignable<value_t>::value&&
        std::is_nothrow_move_constructible<json_value>::value&&
        std::is_nothrow_move_assignable<json_value>::value&&
        std::is_nothrow_move_assignable<json_base_class_t>::value
    )
    {
        // check that passed value is valid
        other.assert_invariant();

        using std::swap;
        swap(m_data.m_type, other.m_data.m_type);
        swap(m_data.m_value, other.m_data.m_value);
        json_base_class_t::operator=(std::move(other));

        set_parents();
        assert_invariant();
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r15
movq %rsi, %rdi
movl %r15d, %esi
callq 0x4a28
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movl %r15d, %esi
callq 0x4a28
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator->() const
pointer operator->() const
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
            {
                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
                return &(m_it.object_iterator->second);
            }

            case value_t::array:
            {
                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
                return &*m_it.array_iterator;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
                {
                    return m_object;
                }

                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xa1be
movq %rdi, %r14
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0xa130
cmpl $0x1, %ecx
jne 0xa15d
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%r14), %rax
cmpq %rcx, %rax
je 0xa1dd
addq $0x40, %rax
jmp 0xa164
movq 0x8(%rax), %rcx
movq 0x10(%r14), %rax
cmpq 0x8(%rcx), %rax
jne 0xa164
leaq 0x7552(%rip), %rdi      # 0x11697
leaq 0x56cf(%rip), %rsi      # 0xf81b
leaq 0x748c(%rip), %rcx      # 0x115df
movl $0x3396, %edx           # imm = 0x3396
callq 0x3210
cmpq $0x0, 0x18(%r14)
jne 0xa16f
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x31c0
movq %rax, %rbx
leaq 0x7553(%rip), %rsi      # 0x116d4
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3130
movq (%r14), %rcx
movb $0x1, %r15b
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0xd6, %esi
callq 0xac90
xorl %r15d, %r15d
leaq 0xfad1(%rip), %rsi      # 0x19c80
leaq -0x2312(%rip), %rdx     # 0x7ea4
movq %rbx, %rdi
callq 0x3500
leaq 0x7222(%rip), %rdi      # 0x113e7
leaq 0x564f(%rip), %rsi      # 0xf81b
leaq 0x740c(%rip), %rcx      # 0x115df
movl $0x338a, %edx           # imm = 0x338A
callq 0x3210
leaq 0x7474(%rip), %rdi      # 0x11658
leaq 0x5630(%rip), %rsi      # 0xf81b
leaq 0x73ed(%rip), %rcx      # 0x115df
movl $0x3390, %edx           # imm = 0x3390
callq 0x3210
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3598
testb %r15b, %r15b
jne 0xa212
jmp 0xa21a
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)3>::construct<nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::string_t const&)
static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
        j.m_data.m_value = s;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movzbl (%r14), %esi
callq 0x4b1a
movb $0x3, (%r14)
movq %rbx, %rdi
callq 0xa956
movq %rax, 0x8(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4a28
nop
// File: /workspace/github_cpp_makefile_star2_O2/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::number_float_t)
static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_float;
        j.m_data.m_value = val;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsd %xmm0, -0x10(%rbp)
movq %rdi, %rbx
addq $0x8, %rdi
movzbl (%rbx), %esi
callq 0x4b1a
movb $0x7, (%rbx)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4a28
movq %rax, %rdi
callq 0x4a1a
// File: /workspace/github_cpp_makefile_star2_O2/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::boolean_t)
static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::boolean;
        j.m_data.m_value = b;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
addq $0x8, %rdi
movzbl (%rbx), %esi
callq 0x4b1a
movb $0x4, (%rbx)
movzbl %r14b, %eax
movq %rax, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4a28
movq %rax, %rdi
callq 0x4a1a
nop
// File: /workspace/github_cpp_makefile_star2_O2/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::number_integer_t)
static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_integer;
        j.m_data.m_value = val;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
movzbl (%rbx), %esi
callq 0x4b1a
movb $0x5, (%rbx)
movq %r14, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4a28
movq %rax, %rdi
callq 0x4a1a
nop
// File: /workspace/github_cpp_makefile_star2_O2/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::number_unsigned_t)
static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_unsigned;
        j.m_data.m_value = val;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
movzbl (%rbx), %esi
callq 0x4b1a
movb $0x6, (%rbx)
movq %r14, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4a28
movq %rax, %rdi
callq 0x4a1a
// File: /workspace/github_cpp_makefile_star2_O2/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool key(string_t& val)
    {
        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(ref_stack.back()->is_object());

        // add null at given key and store the reference for later
        object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0xce7a
movq -0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0xce99
movq %rdi, %rbx
movq 0x8(%rax), %rdi
callq 0xb1e6
movq %rax, 0x20(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x44d0(%rip), %rdi      # 0x11351
leaq 0x2993(%rip), %rsi      # 0xf81b
leaq 0x5239(%rip), %rcx      # 0x120c8
movl $0x1ae0, %edx           # imm = 0x1AE0
callq 0x3210
leaq 0x445f(%rip), %rdi      # 0x112ff
leaq 0x2974(%rip), %rsi      # 0xf81b
leaq 0x521a(%rip), %rcx      # 0x120c8
movl $0x1ae1, %edx           # imm = 0x1AE1
callq 0x3210
// File: /workspace/github_cpp_makefile_star2_O2/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
reference operator[](typename object_t::key_type key)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_data.m_type = value_t::object;
            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
            return set_parent(result.first->second);
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0xdf46
movb $0x1, (%r14)
callq 0x575e
movq %rax, 0x8(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x4a28
movb (%r14), %al
cmpb $0x1, %al
jne 0xdf6d
movq 0x8(%r14), %rdi
leaq -0x40(%rbp), %rdx
andq $0x0, (%rdx)
movq %rbx, %rsi
callq 0xe056
addq $0x40, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x31c0
movq %rax, %rbx
movq %r14, %rdi
callq 0xaf96
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x4627(%rip), %rsi      # 0x125b5
leaq -0x40(%rbp), %rdi
callq 0xdfed
movb $0x1, %r15b
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
movq %r14, %rcx
callq 0xae30
xorl %r15d, %r15d
leaq 0xbd08(%rip), %rsi      # 0x19cc0
leaq -0x611b(%rip), %rdx     # 0x7ea4
movq %rbx, %rdi
callq 0x3500
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3598
testb %r15b, %r15b
jne 0xdfdd
jmp 0xdfe5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/cesarblum[P]propertypp/example.cpp
// Function: Example::printProperties()
void Example::printProperties()
{
    std::cout << "i: " << i
              << "; f: " << f
              << "; p: " << p << " (" << (p ? *p : 0) << ")"
              << std::endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2dac(%rip), %rdi      # 0x3fd8
leaq 0xde1(%rip), %rsi       # 0x2014
callq 0x1070
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
xorl %ebp, %ebp
xorl %esi, %esi
callq *(%rax)
movq %r14, %rdi
movl %eax, %esi
callq 0x10b0
leaq 0xdbf(%rip), %rsi       # 0x2018
movq %rax, %rdi
callq 0x1070
movq %rax, %r14
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq %r14, %rdi
callq 0x1040
leaq 0xda0(%rip), %rsi       # 0x201e
movq %rax, %rdi
callq 0x1070
movq %rax, %r14
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x1050
leaq 0xd7e(%rip), %rsi       # 0x2024
movq %rax, %rdi
callq 0x1070
movq %rax, %r14
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
testq %rax, %rax
je 0x12ce
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movl (%rax), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x10b0
leaq 0xd48(%rip), %rsi       # 0x2027
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
nop
// File: /workspace/github_cpp_makefile_star2_O2/cesarblum[P]propertypp/example.cpp
// Function: main
int main()
{
    Example e;
    e.printProperties(); // should print all 0

    e.i = 14;
    e.f = 2.3;
    e.p = new int;
    *e.p = 5;
    e.printProperties(); // should print assigned values

    e.f = -1.0;
    e.printProperties(); // e.f should be unchanged (see setter above)

    e.i = e.f;           // implicit type conversion
    e.printProperties(); // e.i should equal the integer part of e.f

    e.f = 5.5;
    e.printProperties(); // only e.f should be changed

    e.i = e.f = 9.3;     // chained assignment
    e.printProperties(); // e.i should be 9, e.f should be 9.3

    e.i = *e.p;
    e.printProperties(); // e.i should equal the value pointed to by e.p

    delete e.p;
    e.p = 0;
    e.printProperties(); // e.p should be null

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x11ec
movq %rbx, %rdi
callq 0x121e
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
pushq $0xe
popq %rsi
callq *(%rax)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movss 0xcb4(%rip), %xmm0      # 0x2004
callq *(%rax)
pushq $0x4
popq %r14
movq %r14, %rdi
callq 0x1080
movq 0x40(%rbx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *(%rcx)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movl $0x5, (%rax)
movq %rbx, %rdi
callq 0x121e
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movss 0xc76(%rip), %xmm0      # 0x2008
callq *(%rax)
movq %rbx, %rdi
callq 0x121e
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
cvttss2si %xmm0, %esi
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
callq 0x121e
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movss 0xc41(%rip), %xmm0      # 0x200c
callq *(%rax)
movq %rbx, %rdi
callq 0x121e
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movss 0xc2c(%rip), %xmm0      # 0x2010
callq *(%rax)
cvttss2si %xmm0, %esi
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
callq 0x121e
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movl (%rax), %esi
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
callq 0x121e
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x1090
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq %rbx, %rdi
callq 0x121e
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/main.cpp
// Function: main
int main( int argc, char *argv[] )
{
   char *fname = (char *) (argv[1]);

//while(1) {

   inTec_File f( fname );
   f.OpenRead();
   f.Parse();
   f.Close();
   inTec_Zone *z = f.GetZone( 0 );
   z->Dump( (char*) "CRAPCRAP.dat");//HACK

   printf("Zone type: %d \n", z->GetType() );
   printf("Zone variables: %d \n", z->GetNumVariables() );
   printf("Zone (not real) im: %ld \n",z->GetNumIndices( 1 ) );
   printf("Zone (not real) jm: %ld \n",z->GetNumIndices( 2 ) );
   printf("Zone (not real) km: %ld \n",z->GetNumIndices( 3 ) );
   printf("Zone nodes: %ld elements: %ld \n",
             z->GetNumNodes(), z->GetNumElements() );
   const unsigned long* icon = z->GetConnectivityPtr();
   printf(" %ld %ld %ld %ld \n",icon[0],icon[1],icon[2],icon[3]);
// 41 42 2 1
// 42 43 3 2
// 43 44 4 3
   const double* d = z->GetVariablePtr( 0 );
   printf(" %16.9e %16.9e %16.9e \n", d[0], d[1], d[2] );
//  5.000000000E-02 5.214617101E-02 5.437147251E-02


  printf("========================= LOOP ==========================\n");
//}

   return(0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x10d0
movq %rbx, %rdi
callq 0x1120
leaq 0x8(%rsp), %rdi
callq 0x1030
leaq 0x8(%rsp), %rdi
callq 0x10a0
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1110
movq %rax, %rbx
leaq 0xd7b(%rip), %rsi       # 0x2004
movq %rax, %rdi
callq 0x1130
movq %rbx, %rdi
callq 0x1050
leaq 0xd71(%rip), %rdi       # 0x2011
movl %eax, %esi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x10c0
leaq 0xd69(%rip), %rdi       # 0x2021
movl %eax, %esi
xorl %eax, %eax
callq 0x1040
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x10f0
leaq 0xd63(%rip), %rdi       # 0x2036
movq %rax, %rsi
xorl %eax, %eax
callq 0x1040
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x10f0
leaq 0xd61(%rip), %rdi       # 0x2050
movq %rax, %rsi
xorl %eax, %eax
callq 0x1040
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x10f0
leaq 0xd5f(%rip), %rdi       # 0x206a
movq %rax, %rsi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x10b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1060
leaq 0xd55(%rip), %rdi       # 0x2084
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x1070
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq 0x18(%rax), %r8
leaq 0xd4a(%rip), %rdi       # 0x20a4
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1080
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
leaq 0xd37(%rip), %rdi       # 0x20b7
movb $0x3, %al
callq 0x1040
leaq 0xd41(%rip), %rdi       # 0x20cf
callq 0x10e0
leaq 0x8(%rsp), %rdi
callq 0x1090
xorl %eax, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
jmp 0x13b0
jmp 0x13b0
jmp 0x13b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/bloody76[P]Chip8-Disassembler/src/disassembler.cc
// Function: parse(std::basic_ifstream<char, std::char_traits<char>>&)
void parse(std::ifstream& rom)
{
    uint8   op1 = 0;
    uint8   op2 = 0;
    uint16  op  = 0;

    size = rom.tellg();
    mem = new uint8[size];
    rom.seekg(0, std::ios::beg);
    rom.read((char*)mem, size);
    rom.close();

    for (int i = 0; i < size; i += 2)
    {
        op1 = mem[i];
        if (i + 1 < size)
            op2 = mem[i + 1];
        else
        {
            std::cerr << "Invalid opcode, exiting." << std::endl;
            exit(1);
        }

        op = (op1 << 8) | op2;
        switch ((op & 0xF000) >> 12)
        {
            case 1:
                functions[op & 0x0FFF] = Type::ADR;
                break;
            case 2:
                functions[op & 0x0FFF] = Type::SUB;
                break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x2210
movq %rax, 0x2da8(%rip)      # 0x5180
movq %rdx, 0x2da9(%rip)      # 0x5188
movq %rax, %rdi
callq 0x2030
movq %rax, 0x2d8a(%rip)      # 0x5178
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21a0
movq 0x2d74(%rip), %rsi      # 0x5178
movq 0x2d75(%rip), %rdx      # 0x5180
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2050
leaq 0x2d26(%rip), %rbx      # 0x5148
leaq 0xe(%rsp), %r14
leaq 0xc(%rsp), %r15
movq 0x2d4d(%rip), %rax      # 0x5180
cmpq %r13, %rax
jle 0x24a4
leaq 0x1(%r13), %r12
cmpq %r12, %rax
jbe 0x24b2
movq 0x2d30(%rip), %rax      # 0x5178
movzbl (%rax,%r13), %ecx
movzbl 0x1(%rax,%r13), %edx
movl %ecx, %eax
shll $0x8, %eax
orl %edx, %eax
shrl $0x4, %ecx
cmpl $0x1, %ecx
je 0x2481
cmpl $0x2, %ecx
jne 0x249c
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b04
andl $0x0, (%rax)
jmp 0x249c
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0xe(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b04
movl $0x1, (%rax)
incq %r12
movq %r12, %r13
jmp 0x242c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2b37(%rip), %rdi      # 0x4ff0
leaq 0xbc0(%rip), %rsi       # 0x3080
callq 0x2130
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/bloody76[P]Chip8-Disassembler/src/disassembler.cc
// Function: main
int main(int argc, char** argv)
{
    if (argc < 2)
    {
        std::cerr << "First argument must be a filename." << std::endl;
        return 1;
    }
    std::string file(argv[1]);

    functions[0x200] = Type::SUB;
    std::ifstream rom(file, std::ios::ate);
    if (!rom.is_open())
    {
        std::cerr << "Fill with a valid filename." << std::endl;
        return 1;
    }
    parse(rom);
    pretty_print();
    delete[] mem;
    return 0;
}

// Assembly:
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
cmpl $0x1, %edi
jg 0x2a24
movq 0x25e8(%rip), %rdi      # 0x4ff0
leaq 0x763(%rip), %rsi       # 0x3172
callq 0x2130
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rbx
jmp 0x2acc
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdx
callq 0x2b54
movw $0x200, (%rbx)          # imm = 0x200
leaq 0x2702(%rip), %rdi      # 0x5148
leaq 0x28(%rsp), %rsi
callq 0x2b04
andl $0x0, (%rax)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x2
popq %rdx
callq 0x21d0
leaq 0xa0(%rsp), %rdi
callq 0x2060
testb %al, %al
je 0x2a9a
leaq 0x28(%rsp), %rdi
callq 0x23bc
callq 0x24d5
movq 0x26ec(%rip), %rdi      # 0x5178
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x2ab8
callq 0x2190
jmp 0x2ab8
movq 0x254f(%rip), %rdi      # 0x4ff0
leaq 0x6ed(%rip), %rsi       # 0x3195
callq 0x2130
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rbx
leaq 0x28(%rsp), %rdi
callq 0x2070
leaq 0x8(%rsp), %rdi
callq 0x20c0
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
retq
jmp 0x2ad9
movq %rax, %rbx
jmp 0x2aeb
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2070
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day04/ex02/Squad.cpp
// Function: Squad::operator=(Squad const&)
Squad &Squad::operator=(Squad const &other)
{
	std::cout << "Copy" << std::endl;
	for (int i = 0; i < this->current; i++)
		delete this->units[i];
	delete []this->units;
	this->units = 0;
	this->current = 0;
	for (int i = 0; i < other.getCount(); i++)
		this->push(other.getUnit(i)->clone());
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2b97(%rip), %rdi      # 0x3fd8
leaq 0xc5a(%rip), %rsi       # 0x20a2
callq 0x1080
movq %rax, %rdi
callq 0x1060
xorl %r15d, %r15d
movslq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
cmpq %rax, %r15
jge 0x1479
movq (%rdi,%r15,8), %rdi
testq %rdi, %rdi
je 0x1474
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
jmp 0x1458
testq %rdi, %rdi
je 0x1483
callq 0x10b0
andq $0x0, 0x10(%rbx)
andl $0x0, 0x8(%rbx)
xorl %r15d, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl %eax, %r15d
jge 0x14c3
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
callq *0x18(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rcx)
incl %r15d
jmp 0x148f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day04/ex02/Squad.cpp
// Function: Squad::~Squad()
Squad::~Squad(void)
{
	for (int i = 0; i < this->current; i++)
		delete this->units[i];
	delete []this->units;
	this->units = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x282d(%rip), %rax      # 0x3d10
movq %rax, (%rdi)
xorl %r14d, %r14d
movslq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
cmpq %rax, %r14
jge 0x150a
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x1505
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
jmp 0x14e9
testq %rdi, %rdi
je 0x1514
callq 0x10b0
andq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day04/ex02/Squad.cpp
// Function: Squad::push(ISpaceMarine*)
int Squad::push(ISpaceMarine *unit)
{
	if (unit == 0)
		return (0);
	for (int i = 0; i < this->current; i++)
	{
		if (this->units[i] == unit)
			return (0);
	}
	ISpaceMarine **tmp = new ISpaceMarine*[this->current + 1];
	for (int i = 0; i < this->current; i++)
		tmp[i] = this->units[i];
	tmp[this->current++] = unit;
	if (this->units != 0)
		delete []this->units;
	this->units = tmp;
	return (1);
}

// Assembly:
testq %rsi, %rsi
je 0x15ab
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movslq 0x8(%rdi), %r13
movq %rdi, -0x38(%rbp)
movq 0x10(%rdi), %r15
xorl %eax, %eax
testl %r13d, %r13d
movl $0x0, %ebx
cmovgl %r13d, %ebx
cmpq %rax, %rbx
je 0x15ae
leaq 0x1(%rax), %rcx
cmpq %r14, (%r15,%rax,8)
movq %rcx, %rax
jne 0x1595
xorl %eax, %eax
jmp 0x1608
xorl %eax, %eax
retq
leaq 0x1(%r13), %rax
movq %rax, -0x30(%rbp)
cmpl $-0x1, %r13d
leaq 0x8(,%r13,8), %rax
pushq $-0x1
popq %rdi
cmovgeq %rax, %rdi
callq 0x1030
movq %rax, %r12
xorl %eax, %eax
cmpq %rax, %rbx
je 0x15e5
movq (%r15,%rax,8), %rcx
movq %rcx, (%r12,%rax,8)
incq %rax
jmp 0x15d3
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %rax
movl %eax, 0x8(%rbx)
movq %r14, (%r12,%r13,8)
testq %r15, %r15
je 0x1601
movq %r15, %rdi
callq 0x10b0
movq %r12, 0x10(%rbx)
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day04/ex02/main.cpp
// Function: main
int main(void)
{
	ISpaceMarine* bob = new TacticalMarine;
	ISpaceMarine* jim = new AssaultTerminator;
	Squad *vlc = new Squad;
	Squad copy;
	vlc->push(bob);
	copy = *vlc;
	vlc->push(jim);
	std::cout << "--- First squad ---" << std::endl;
	for (int i = 0; i < vlc->getCount(); ++i)
	{
		ISpaceMarine* cur = vlc->getUnit(i);
		cur->battleCry();
		cur->rangedAttack();
		cur->meleeAttack();
	}
	std::cout << "--- Second squad ---" << std::endl;
	for (int i = 0; i < copy.getCount(); ++i)
	{
		ISpaceMarine* cur = copy.getUnit(i);
		cur->battleCry();
		cur->rangedAttack();
		cur->meleeAttack();
	}
	delete vlc;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
pushq $0x8
popq %rdi
callq 0x1090
movq %rax, %r12
movq %rax, %rdi
callq 0x1618
pushq $0x8
popq %rdi
callq 0x1090
movq %rax, %r14
movq %rax, %rdi
callq 0x12ac
pushq $0x18
popq %rdi
callq 0x1090
movq %rax, %rbx
movq %rax, %rdi
callq 0x13ec
leaq -0x38(%rbp), %rdi
callq 0x13ec
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0x20(%rax)
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x142a
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rax)
movq 0x2814(%rip), %rdi      # 0x3fd8
leaq 0x970(%rip), %rsi       # 0x213b
callq 0x1080
movq %rax, %rdi
callq 0x1060
xorl %r14d, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
cmpl %eax, %r14d
jge 0x1818
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x18(%rax)
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
incl %r14d
jmp 0x17db
movq 0x27b9(%rip), %rdi      # 0x3fd8
leaq 0x929(%rip), %rsi       # 0x214f
callq 0x1080
movq %rax, %rdi
callq 0x1060
xorl %r14d, %r14d
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x153e
cmpl %eax, %r14d
jge 0x1877
movq %r15, %rdi
movl %r14d, %esi
callq 0x1548
movq %rax, %r12
movq (%rax), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x20(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
incl %r14d
jmp 0x183a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
leaq -0x38(%rbp), %rdi
callq 0x14d2
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
pushq $0x18
popq %rsi
movq %rbx, %rdi
jmp 0x18b7
movq %rax, %r15
pushq $0x8
popq %rsi
movq %r14, %rdi
jmp 0x18b7
movq %rax, %r15
pushq $0x8
popq %rsi
movq %r12, %rdi
callq 0x10a0
jmp 0x18d2
jmp 0x18c6
jmp 0x18c6
jmp 0x18c6
jmp 0x18c6
movq %rax, %r15
leaq -0x38(%rbp), %rdi
callq 0x14d2
movq %r15, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/princelab[P]emass/emass.cpp
// Function: convolute_basic(std::vector<peak, std::allocator<peak>>&, std::vector<peak, std::allocator<peak>> const&, std::vector<peak, std::allocator<peak>> const&)
void convolute_basic(Pattern & h, const Pattern & g, const Pattern & f)
{
  h.clear();
  size_t g_n = g.size();
  size_t f_n = f.size();
  if(g_n == 0 || f_n == 0)
     return;
  for(size_t k = 0; k < g_n + f_n - 1; k++) {
    double sumweight = 0, summass = 0;
    size_t start = k < (f_n - 1) ? 0 : k - f_n + 1; // max(0, k-f_n+1)
    size_t end = k < (g_n - 1) ? k : g_n - 1;       // min(g_n - 1, k)
    for(size_t i = start; i <= end; i++) {
      double weight = g[i].rel_area * f[k - i].rel_area;
      double mass = g[i].mass + f[k - i].mass;
      sumweight += weight;
      summass += weight * mass;
    }
    peak p;
    if(sumweight == 0)
      p.mass = DUMMY_MASS;
    else
      p.mass = summass / sumweight;
    p.rel_area = sumweight;
    h.push_back(p);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x3971
movq %rax, 0x8(%r15)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r13
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rbp
subq (%rax), %r13
sete %al
subq (%rcx), %rbp
sete %cl
orb %al, %cl
je 0x39a2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %r12
sarq $0x4, %r12
sarq $0x4, %r13
leaq (%r12,%r13), %rax
decq %rax
movq %rax, 0x20(%rsp)
decq %r13
leaq -0x1(%r12), %r14
pushq $0x18
popq %rax
subq %rbp, %rax
movq %rax, 0x18(%rsp)
addq $-0x8, %rbp
xorl %ebx, %ebx
negq %r12
cmpq %r14, %rbx
movq %r14, %rdi
cmovaq %rbx, %rdi
cmpq 0x20(%rsp), %rbx
je 0x3993
shlq $0x4, %rdi
movq %rdi, %rax
negq %rax
cmpq %r14, %rbx
leaq 0x1(%rbx,%r12), %rdx
movl $0x0, %ecx
cmovaeq %rdx, %rcx
cmpq %r13, %rbx
movq %r13, %rdx
cmovbq %rbx, %rdx
movq 0x8(%rsp), %rsi
movq (%rsi), %rsi
addq 0x18(%rsp), %rsi
addq %rdi, %rsi
movq 0x10(%rsp), %rdi
movq (%rdi), %rdi
addq %rbp, %rdi
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rdx, %rcx
ja 0x3a60
movsd -0x8(%rsi), %xmm2
movsd (%rsi), %xmm3
mulsd (%rdi,%rax), %xmm3
addsd -0x8(%rdi,%rax), %xmm2
addsd %xmm3, %xmm0
mulsd %xmm3, %xmm2
addsd %xmm2, %xmm1
incq %rcx
addq $0x10, %rsi
addq $-0x10, %rdi
jmp 0x3a2e
divsd %xmm0, %xmm1
movapd %xmm0, %xmm2
cmpeqsd 0x35a7(%rip), %xmm2     # 0x7018
movapd %xmm2, %xmm3
andnpd %xmm1, %xmm3
movsd 0x358f(%rip), %xmm1     # 0x7010
andpd %xmm1, %xmm2
orpd %xmm3, %xmm2
movlpd %xmm2, 0x28(%rsp)
movsd %xmm0, 0x30(%rsp)
movq %r15, %rdi
leaq 0x28(%rsp), %rsi
callq 0x4418
incq %rbx
addq $0x10, %rbp
jmp 0x39d5
// File: /workspace/github_cpp_makefile_star2_O2/princelab[P]emass/emass.cpp
// Function: prune(std::vector<peak, std::allocator<peak>>&, double)
void prune(Pattern & f, double limit)
{
  // prune the front
  Pattern::iterator i = f.begin();
  while(i != f.end()) {
    if((*i).rel_area > limit)
      break;
    i++;
  }
  f.erase(f.begin(), i);

  // prune the end
  while(1) {
    if(f.size() == 0)
      break;
    if(f.back().rel_area > limit)
      break;
    f.pop_back();
  } 
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
movq %rsi, %rdx
cmpq %rax, %rdx
je 0x3ad6
movsd 0x8(%rdx), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3ad6
addq $0x10, %rdx
jmp 0x3ac0
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x4436
movsd 0x8(%rsp), %xmm1
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x3b0b
movsd -0x8(%rcx), %xmm0
ucomisd %xmm1, %xmm0
ja 0x3b0b
addq $-0x10, %rcx
movq %rcx, 0x8(%rbx)
jmp 0x3af1
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/princelab[P]emass/emass.cpp
// Function: print_pattern(std::vector<peak, std::allocator<peak>>&, int)
void print_pattern(Pattern & result, int digits)
{
  // find the maximum
  double max_area = 0;
  double sum_area = 0;
  for(Pattern::iterator i = result.begin(); i != result.end(); ++i) {
    if(max_area < (*i).rel_area)
      max_area = (*i).rel_area;
    sum_area += (*i).rel_area;
  }
  if(max_area == 0)
    return; // empty pattern

  wcout.setf(ios::fixed);
  wcout.precision(digits);
  double print_limit = pow(10.0, -digits) / 2;
  //wcout.precision(30);
  //double print_limit = 0.000001 / 2;
  for(Pattern::iterator i = result.begin(); i != result.end(); ++i) {
    double mass = (*i).mass;
    double rel_area = (*i).rel_area;
    double val_perc = rel_area / max_area * 100;
    //double val_norm = rel_area / sum_area;
    if(mass != DUMMY_MASS && val_perc >= print_limit)
      wcout << mass << L" " << val_perc << endl;
    //wcout << mass << L" " << val_perc << L" " << val_norm << endl;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm1, %xmm1
cmpq %rcx, %rax
je 0x3b42
movsd 0x8(%rax), %xmm0
maxsd %xmm1, %xmm0
addq $0x10, %rax
movapd %xmm0, %xmm1
jmp 0x3b2a
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x3b5a
jp 0x3b5a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x746f(%rip), %r14      # 0xafd0
movq (%r14), %rax
movq -0x18(%rax), %rcx
orl $0x4, 0x18(%r14,%rcx)
movq -0x18(%rax), %rax
movslq %esi, %rcx
movq %rcx, 0x8(%r14,%rax)
negl %ecx
movsd %xmm1, (%rsp)
cvtsi2sd %ecx, %xmm1
movsd 0x3493(%rip), %xmm0     # 0x7020
callq 0x33d0
movsd (%rsp), %xmm1
mulsd 0x3489(%rip), %xmm0     # 0x7028
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %r12
movsd 0x3480(%rip), %xmm2     # 0x7030
movsd 0x3458(%rip), %xmm3     # 0x7010
leaq 0x34dd(%rip), %r15      # 0x709c
cmpq 0x8(%rbx), %r12
je 0x3b4e
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm4
divsd %xmm1, %xmm4
mulsd %xmm2, %xmm4
ucomisd %xmm3, %xmm0
jne 0x3be2
jnp 0x3c2e
ucomisd 0x8(%rsp), %xmm4
jb 0x3c2e
movq %r14, %rdi
movsd %xmm4, 0x10(%rsp)
callq 0x33e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x3430
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x33e0
movq %rax, %rdi
callq 0x3130
movsd 0x33ef(%rip), %xmm3     # 0x7010
movsd 0x3407(%rip), %xmm2     # 0x7030
movsd (%rsp), %xmm1
addq $0x10, %r12
jmp 0x3bbf
// File: /workspace/github_cpp_makefile_star2_O2/princelab[P]emass/parser.cpp
// Function: Parser::parse_formula(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
void Parser::parse_formula(const wstring & frml)
{
  _tokenizer.set_input(frml);
  _tokenizer.get_token();
  Parser::ElementListNode * tmp = parse();
  
  if(_tokenizer._ttype != EOS) {
    delete tmp; 
    _tokenizer.error(L"End of input expected");
  }
  delete tmp;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x5602
movq %rbx, %rdi
callq 0x5628
movq %r14, %rdi
callq 0x595a
cmpl $0x2, 0x8(%r14)
jne 0x55ba
testq %rax, %rax
je 0x55b2
movq (%rax), %rcx
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmpq *0x8(%rcx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
testq %rax, %rax
je 0x55c8
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
leaq 0x1c11(%rip), %rsi      # 0x71e0
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x5eca
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b84
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x34c0
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/princelab[P]emass/parser.cpp
// Function: Parser::Tokenizer::error(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>)
void Parser::Tokenizer::error(wstring msg)
{
  msg += L":\n";
  _input.resize(_input.length() - ENDTOKEN.length());
  msg += _input + L"\n";
  msg += wstring(_last, L' ') + L"^\n";
  throw Parser::Error(msg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x176f(%rip), %rsi      # 0x730c
movq %rbx, %rdi
callq 0x3420
leaq 0x38(%r14), %r15
movq 0x40(%r14), %rsi
subq 0x5794(%rip), %rsi      # 0xb348
movq %r15, %rdi
callq 0x3440
leaq 0x174d(%rip), %rdx      # 0x7310
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5fb3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3400
movq %rsp, %rdi
callq 0x34c0
movq 0x30(%r14), %rsi
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x20(%rsp), %rdi
pushq $0x20
popq %rdx
callq 0x3470
leaq 0x1713(%rip), %rdx      # 0x7318
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x5f09
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3400
movq %rsp, %rdi
callq 0x34c0
leaq 0x20(%rsp), %rdi
callq 0x34c0
pushq $0x20
popq %rdi
callq 0x3110
movq %rax, %r14
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x3220
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
callq 0x3220
xorl %ebp, %ebp
leaq 0x5098(%rip), %rsi      # 0xacf8
leaq 0x29d(%rip), %rdx       # 0x5f04
movq %r14, %rdi
callq 0x33c0
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x34c0
testb %bpl, %bpl
jne 0x5c86
jmp 0x5cb7
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
jmp 0x5cb7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x34c0
jmp 0x5ca0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x5cb2
movq %rax, %rbx
jmp 0x5cb7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x34c0
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/princelab[P]emass/parser.cpp
// Function: Parser::write_compound(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>>&)
void Parser::write_compound(const wstring & frml, FormMap & c)
{
  c.clear();

  _tokenizer.set_input(frml);
  _tokenizer.get_token();
  Parser::ElementListNode * tmp = parse();
  
  if(_tokenizer._ttype != EOS) {
    delete tmp;	
    _tokenizer.error(L"End of input expected");
  }

  tmp->fill_compound(1, c);
  cleanUpFormula(c);
  delete tmp;	
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0x5440
leaq 0x8(%r12), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5602
movq %rbx, %rdi
callq 0x5628
movq %r12, %rdi
callq 0x595a
movq %rax, %r15
cmpl $0x2, 0x8(%r12)
jne 0x5d32
movq (%r15), %rax
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq *0x10(%rax)
movq %r14, %rdi
callq 0x6544
movq (%r15), %rax
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *0x8(%rax)
testq %r15, %r15
je 0x5d40
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x1499(%rip), %rsi      # 0x71e0
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x5eca
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b84
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x34c0
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/princelab[P]emass/parser.cpp
// Function: Parser::ElementListNode::~ElementListNode()
Parser::ElementListNode::~ElementListNode()
{
  for(NodeList::iterator i = _NodeList.begin();
      i != _NodeList.end();
      ++i)
    {
      delete *i;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4f24(%rip), %rax      # 0xad18
movq %rax, (%rdi)
addq $0x8, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x5e17
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x5dfe
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x5dfe
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x63b2
// File: /workspace/github_cpp_makefile_star2_O2/princelab[P]emass/parser.cpp
// Function: Parser::ElementListNode::fill_compound(unsigned long, std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>>&) const
void Parser::ElementListNode::fill_compound(ulong weight, FormMap & c) const
{
  ulong totalweight = _count * weight;
  
  for(NodeList::const_iterator i = _NodeList.begin();
      i != _NodeList.end();
      ++i)
    {
      (*i)->fill_compound(totalweight, c);
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
imulq 0x20(%rdi), %r14
addq $0x8, %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x5e75
movq 0x10(%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
jmp 0x5e59
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/princelab[P]emass/formula.cpp
// Function: cleanUpFormula(std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>>&)
void cleanUpFormula(FormMap & form) {
  
  typedef std::vector<size_t> Erasable;

  Erasable e;
  for(FormMap::iterator i = form.begin(); i != form.end(); ++i)
    if(i->second == 0)
      e.push_back(i->first);

  for(Erasable::iterator i = e.begin(); i != e.end(); ++i)
      form.erase(*i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq 0x18(%rdi), %r15
leaq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x658e
cmpq $0x0, 0x28(%r15)
jne 0x6581
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x66be
movq %r15, %rdi
callq 0x3170
movq %rax, %r15
jmp 0x6569
movq (%rsp), %r14
cmpq 0x8(%rsp), %r14
je 0x65aa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6a04
addq $0x8, %r14
jmp 0x6592
movq %rsp, %rdi
callq 0x688c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x65c0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x688c
movq %rbx, %rdi
callq 0x33f0