LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::detail::BasicResult<Catch::clara::detail::ParseResultType> Catch::clara::detail::convertInto<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&)
inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
        std::stringstream ss;
        ss << source;
        ss >> target;
        if( ss.fail() )
            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
        else
            return ParserResult::ok( ParseResultType::Matched );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1e0(%rbp), %rdi
callq 0x1b390
leaq -0x1d0(%rbp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x1b5e0
leaq -0x1e0(%rbp), %rdi
movq %r15, %rsi
callq 0x1b2d0
movq -0x1e0(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1c0(%rbp,%rax)
je 0x4b628
leaq 0x31aa4(%rip), %rsi     # 0x7d08c
leaq -0x58(%rbp), %rdi
movq %r14, %rdx
callq 0x3f209
leaq 0x31aa5(%rip), %rsi     # 0x7d0a0
leaq -0x58(%rbp), %rdi
callq 0x1b9d0
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4b64e
movq %rdx, -0x38(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x28(%rbp)
jmp 0x4b655
xorl %eax, %eax
movq %rax, 0x8(%rbx)
leaq 0x5d053(%rip), %rcx     # 0xa8688
addq $0x10, %rcx
movq %rcx, (%rbx)
leaq 0x20(%rbx), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
jmp 0x4b69d
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rsi
leaq -0x38(%rbp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x4b50e
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x4b68b
callq 0x1b4d0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4b69d
callq 0x1b4d0
movq 0x5e86c(%rip), %rsi     # 0xa9f10
leaq -0x1e0(%rbp), %rdi
callq 0x1b3e0
leaq -0x160(%rbp), %rdi
callq 0x1b170
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x4b6e3
callq 0x1b4d0
jmp 0x4b6e3
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4b6fc
callq 0x1b4d0
jmp 0x4b6fc
jmp 0x4b6f9
movq %rax, %rbx
movq 0x5e80d(%rip), %rsi     # 0xa9f10
leaq -0x1e0(%rbp), %rdi
callq 0x1b3e0
leaq -0x160(%rbp), %rdi
callq 0x1b170
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::skip_bom()
bool skip_bom()
    {
        if (get() == 0xEF)
        {
            // check if we completely parse the BOM
            return get() == 0xBB && get() == 0xBF;
        }

        // the first character is not the beginning of the BOM; unget it to
        // process is later
        unget();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1c1d6
cmpl $0xef, %eax
je 0x6605a
movq %rbx, %rdi
callq 0x66976
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x1c1d6
cmpl $0xbb, %eax
je 0x6606d
xorl %eax, %eax
jmp 0x66053
movq %rbx, %rdi
callq 0x1c1d6
cmpl $0xbf, %eax
sete %al
jmp 0x66053
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::unget()
void unget()
    {
        next_unget = true;

        --position.chars_read_total;

        // in case we "unget" a newline, we have to also decrement the lines_read
        if (position.chars_read_current_line == 0)
        {
            if (position.lines_read > 0)
            {
                --position.lines_read;
            }
        }
        else
        {
            --position.chars_read_current_line;
        }

        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
        {
            JSON_ASSERT(!token_string.empty());
            token_string.pop_back();
        }
    }

// Assembly:
movb $0x1, 0x18(%rdi)
decq 0x20(%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x6698d
leaq 0x28(%rdi), %rcx
jmp 0x6699a
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x669a0
leaq 0x30(%rdi), %rcx
decq %rax
movq %rax, (%rcx)
cmpl $-0x1, 0x14(%rdi)
je 0x669b7
movq 0x40(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x669b8
decq %rax
movq %rax, 0x40(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x19af4(%rip), %rdi     # 0x804b7
leaq 0x196e5(%rip), %rsi     # 0x800af
leaq 0x19afc(%rip), %rcx     # 0x804cd
movl $0x21fc, %edx           # imm = 0x21FC
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: bool nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::parse_error<nlohmann::json_abi_v3_11_2::detail::parse_error>(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_2::detail::parse_error const&)
bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
                     const Exception& ex)
    {
        errored = true;
        static_cast<void>(ex);
        if (allow_exceptions)
        {
            JSON_THROW(ex);
        }
        return false;
    }

// Assembly:
movb $0x1, 0x78(%rdi)
cmpb $0x1, 0xa0(%rdi)
je 0x6776c
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl $0x28, %edi
callq 0x1b250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6cffa
leaq 0x42303(%rip), %rsi     # 0xa9a98
leaq 0x556(%rip), %rdx       # 0x67cf2
movq %r14, %rdi
callq 0x1b8b0
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get_token_string() const
std::string get_token_string() const
    {
        // escape control characters
        std::string result;
        for (const auto c : token_string)
        {
            if (static_cast<unsigned char>(c) <= '\x1F')
            {
                // escape control characters
                std::array<char, 9> cs{{}};
                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
                result += cs.data();
            }
            else
            {
                // add character as is
                result.push_back(static_cast<std::string::value_type>(c));
            }
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x40(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %r12
cmpq %r12, %r13
je 0x6782f
leaq 0x1acb7(%rip), %r14     # 0x8249a
leaq -0x38(%rbp), %r15
movzbl (%r13), %ecx
cmpl $0x1f, %ecx
ja 0x6781c
movb $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x9, %esi
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1b800
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b9d0
jmp 0x67827
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x1b480
incq %r13
cmpq %r12, %r13
jne 0x677e7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x67843
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x40(%rbp), %rdi
je 0x67854
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(nlohmann::json_abi_v3_11_2::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_2::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_type, other.m_type);
        swap(m_value, other.m_value);
        json_base_class_t::operator=(std::move(other));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x65866
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 $0x1, %esi
callq 0x65866
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::start_array(unsigned long)
bool start_array(std::size_t len)
    {
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
        keep_stack.push_back(keep);

        auto val = handle_value(BasicJsonType::value_t::array, true);
        ref_stack.push_back(val.second);

        // check array limit
        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
        {
            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
shrq $0x3, %rax
movl %eax, -0x58(%rbp)
movb $0x2, -0x38(%rbp)
cmpq $0x0, 0x90(%rdi)
je 0x693c7
movq %rsi, %r15
movq %rdi, %rbx
addq $0x80, %rdi
leaq 0xa8(%rbx), %rcx
leaq -0x58(%rbp), %r14
leaq -0x38(%rbp), %rdx
movq %r14, %rsi
callq *0x98(%rbx)
leaq 0x20(%rbx), %rdi
movzbl %al, %esi
callq 0x689a2
movb $0x2, (%r14)
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x697e8
movb %al, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x6931a
movq %rdx, (%rsi)
movq 0x10(%rbx), %rax
addq $0x8, %rax
movq %rax, 0x10(%rbx)
jmp 0x6932b
leaq 0x8(%rbx), %rdi
leaq -0x60(%rbp), %rdx
callq 0x69ff0
movq 0x10(%rbx), %rax
cmpq $-0x1, %r15
je 0x69358
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x69358
movzbl (%rax), %eax
movl $0x1, %ecx
cmpq $0x2, %rax
ja 0x69353
leaq 0x19b91(%rip), %rcx     # 0x82ee0
movq (%rcx,%rax,8), %rcx
cmpq %r15, %rcx
jb 0x69365
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b250
movq %rax, %r14
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x69d17
leaq 0x18bb8(%rip), %rsi     # 0x81f3d
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x6bb67
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x58(%rbp), %rdx
movq %r14, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x69afe
xorl %r15d, %r15d
leaq 0x40620(%rip), %rsi     # 0xa99d8
leaq -0x16cd(%rip), %rdx     # 0x67cf2
movq %r14, %rdi
callq 0x1b8b0
callq 0x1b1b0
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x693e1
callq 0x1b4d0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x693f3
callq 0x1b4d0
testb %r15b, %r15b
jne 0x69414
jmp 0x6941c
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x69414
callq 0x1b4d0
jmp 0x69414
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b3c0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array()
bool end_array()
    {
        bool keep = true;

        if (ref_stack.back())
        {
            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
            if (keep)
            {
                ref_stack.back()->set_parents();
            }
            else
            {
                // discard array
                *ref_stack.back() = discarded;
            }
        }

        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(!keep_stack.empty());
        ref_stack.pop_back();
        keep_stack.pop_back();

        // remove discarded value
        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
        {
            ref_stack.back()->m_value.array->pop_back();
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r14b
testq %rcx, %rcx
je 0x694a8
subq 0x8(%rbx), %rax
shrq $0x3, %rax
decl %eax
movl %eax, -0x18(%rbp)
movb $0x3, -0x11(%rbp)
cmpq $0x0, 0x90(%rbx)
je 0x69564
leaq 0x80(%rbx), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x11(%rbp), %rdx
callq *0x98(%rbx)
testb %al, %al
jne 0x694a8
leaq 0xa8(%rbx), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x6a1e6
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
movq %r14, %rsi
callq 0x67d20
movq %r14, %rdi
callq 0x6503c
xorl %r14d, %r14d
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
cmpq %rax, %rcx
je 0x69526
movq 0x30(%rbx), %rdx
movl 0x38(%rbx), %esi
cmpq %rdx, 0x20(%rbx)
sete %dil
testl %esi, %esi
sete %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
je 0x69545
leaq -0x8(%rax), %rdi
movq %rdi, 0x10(%rbx)
subl $0x1, %esi
movl %esi, 0x38(%rbx)
jae 0x694f2
movl $0x3f, 0x38(%rbx)
addq $-0x8, %rdx
movq %rdx, 0x30(%rbx)
cmpq %rdi, %rcx
sete %cl
orb %cl, %r14b
jne 0x6951b
movq -0x10(%rax), %rax
cmpb $0x2, (%rax)
jne 0x6951b
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
addq $-0x10, %rdi
movq %rdi, 0x8(%rax)
callq 0x6503c
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1858e(%rip), %rdi     # 0x81abb
leaq 0x16b7b(%rip), %rsi     # 0x800af
leaq 0x18a19(%rip), %rcx     # 0x81f54
movl $0x1bb3, %edx           # imm = 0x1BB3
callq 0x1b320
leaq 0x18411(%rip), %rdi     # 0x8195d
leaq 0x16b5c(%rip), %rsi     # 0x800af
leaq 0x189fa(%rip), %rcx     # 0x81f54
movl $0x1bb4, %edx           # imm = 0x1BB4
callq 0x1b320
callq 0x1b1b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_2::detail::external_constructor<(nlohmann::json_abi_v3_11_2::detail::value_t)3>::construct<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_2::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_2::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_value.destroy(j.m_type);
        j.m_type = value_t::string;
        j.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 0x6b416
movb $0x3, (%r14)
movq %rbx, %rdi
callq 0x6ab04
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x65866
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_2::detail::external_constructor<(nlohmann::json_abi_v3_11_2::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_2::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_2::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_value.destroy(j.m_type);
        j.m_type = value_t::number_float;
        j.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 0x6b416
movb $0x7, (%rbx)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x65866
movq %rax, %rdi
callq 0x3e96e
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_2::detail::external_constructor<(nlohmann::json_abi_v3_11_2::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_2::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_2::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_value.destroy(j.m_type);
        j.m_type = value_t::boolean;
        j.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 0x6b416
movb $0x4, (%rbx)
movzbl %r14b, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x65866
movq %rax, %rdi
callq 0x3e96e
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_2::detail::external_constructor<(nlohmann::json_abi_v3_11_2::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_2::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_2::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_value.destroy(j.m_type);
        j.m_type = value_t::number_integer;
        j.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 0x6b416
movb $0x5, (%rbx)
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x65866
movq %rax, %rdi
callq 0x3e96e
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_2::detail::external_constructor<(nlohmann::json_abi_v3_11_2::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_2::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_2::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_value.destroy(j.m_type);
        j.m_type = value_t::number_unsigned;
        j.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 0x6b416
movb $0x6, (%rbx)
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x65866
movq %rax, %rdi
callq 0x3e96e
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::start_object(unsigned long)
bool start_object(std::size_t len)
    {
        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));

        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
        {
            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq -0x38(%rbp), %rsi
movb $0x1, (%rsi)
callq 0x6d792
movq %rax, -0x58(%rbp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x6d3df
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x6d3ec
leaq 0x8(%r14), %rdi
leaq -0x58(%rbp), %rdx
callq 0x6d89e
cmpq $-0x1, %r15
je 0x6d418
movq 0x10(%r14), %rax
movq -0x8(%rax), %rax
movzbl (%rax), %eax
movl $0x1, %ecx
cmpq $0x2, %rax
ja 0x6d413
leaq 0x15ad1(%rip), %rcx     # 0x82ee0
movq (%rcx,%rax,8), %rcx
cmpq %r15, %rcx
jb 0x6d425
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b250
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x69d17
leaq 0x14500(%rip), %rsi     # 0x81945
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x69c9b
movq 0x10(%r14), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x69afe
xorl %r15d, %r15d
leaq 0x3c560(%rip), %rsi     # 0xa99d8
leaq -0x578d(%rip), %rdx     # 0x67cf2
movq %rbx, %rdi
callq 0x1b8b0
movq %rax, %r14
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d49c
callq 0x1b4d0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d4ae
callq 0x1b4d0
testb %r15b, %r15b
jne 0x6d4cf
jmp 0x6d4d7
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d4cf
callq 0x1b4d0
jmp 0x6d4cf
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b3c0
movq %r14, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_object()
bool end_object()
    {
        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(ref_stack.back()->is_object());

        ref_stack.back()->set_parents();
        ref_stack.pop_back();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x6d503
movq -0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x6d522
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rbp
retq
leaq 0x145b1(%rip), %rdi     # 0x81abb
leaq 0x12b9e(%rip), %rsi     # 0x800af
leaq 0x1529c(%rip), %rcx     # 0x827b4
movl $0x1aa9, %edx           # imm = 0x1AA9
callq 0x1b320
leaq 0x14540(%rip), %rdi     # 0x81a69
leaq 0x12b7f(%rip), %rsi     # 0x800af
leaq 0x1527d(%rip), %rcx     # 0x827b4
movl $0x1aaa, %edx           # imm = 0x1AAA
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_2::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_2::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_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 0x6d574
movq -0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x6d593
movq %rdi, %rbx
movq 0x8(%rax), %rdi
callq 0x6b35a
movq %rax, 0x20(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x14540(%rip), %rdi     # 0x81abb
leaq 0x12b2d(%rip), %rsi     # 0x800af
leaq 0x152a5(%rip), %rcx     # 0x8282e
movl $0x1a9f, %edx           # imm = 0x1A9F
callq 0x1b320
leaq 0x144cf(%rip), %rdi     # 0x81a69
leaq 0x12b0e(%rip), %rsi     # 0x800af
leaq 0x15286(%rip), %rcx     # 0x8282e
movl $0x1aa0, %edx           # imm = 0x1AA0
callq 0x1b320
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::start_array(unsigned long)
bool start_array(std::size_t len)
    {
        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));

        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
        {
            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq -0x38(%rbp), %rsi
movb $0x2, (%rsi)
callq 0x6d792
movq %rax, -0x58(%rbp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x6d5e9
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x6d5f6
leaq 0x8(%r14), %rdi
leaq -0x58(%rbp), %rdx
callq 0x6d89e
cmpq $-0x1, %r15
je 0x6d622
movq 0x10(%r14), %rax
movq -0x8(%rax), %rax
movzbl (%rax), %eax
movl $0x1, %ecx
cmpq $0x2, %rax
ja 0x6d61d
leaq 0x158c7(%rip), %rcx     # 0x82ee0
movq (%rcx,%rax,8), %rcx
cmpq %r15, %rcx
jb 0x6d62f
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b250
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x69d17
leaq 0x148ee(%rip), %rsi     # 0x81f3d
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x6bb67
movq 0x10(%r14), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x69afe
xorl %r15d, %r15d
leaq 0x3c356(%rip), %rsi     # 0xa99d8
leaq -0x5997(%rip), %rdx     # 0x67cf2
movq %rbx, %rdi
callq 0x1b8b0
movq %rax, %r14
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d6a6
callq 0x1b4d0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d6b8
callq 0x1b4d0
testb %r15b, %r15b
jne 0x6d6d9
jmp 0x6d6e1
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d6d9
callq 0x1b4d0
jmp 0x6d6d9
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b3c0
movq %r14, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_2::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_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array()
bool end_array()
    {
        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(ref_stack.back()->is_array());

        ref_stack.back()->set_parents();
        ref_stack.pop_back();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x6d70d
movq -0x8(%rax), %rcx
cmpb $0x2, (%rcx)
jne 0x6d72c
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rbp
retq
leaq 0x143a7(%rip), %rdi     # 0x81abb
leaq 0x12994(%rip), %rsi     # 0x800af
leaq 0x15189(%rip), %rcx     # 0x828ab
movl $0x1abf, %edx           # imm = 0x1ABF
callq 0x1b320
leaq 0x151f1(%rip), %rdi     # 0x82924
leaq 0x12975(%rip), %rsi     # 0x800af
leaq 0x1516a(%rip), %rcx     # 0x828ab
movl $0x1ac0, %edx           # imm = 0x1AC0
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::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_2::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_type = value_t::object;
            m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            auto result = 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 0x72389
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x1b510
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x65866
movb (%r14), %al
cmpb $0x1, %al
jne 0x723b3
movq 0x8(%r14), %rdi
leaq -0x40(%rbp), %rdx
movq $0x0, (%rdx)
movq %rbx, %rsi
callq 0x724ca
addq $0x40, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b250
movq %rax, %rbx
movq %r14, %rdi
callq 0x6b1ec
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x115d3(%rip), %rsi     # 0x839a9
leaq -0x40(%rbp), %rdi
callq 0x7243e
movb $0x1, %r15b
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
movq %r14, %rcx
callq 0x6afc4
xorl %r15d, %r15d
leaq 0x37658(%rip), %rsi     # 0xa9a58
leaq -0xa715(%rip), %rdx     # 0x67cf2
movq %rbx, %rdi
callq 0x1b8b0
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x72424
callq 0x1b4d0
testb %r15b, %r15b
jne 0x7242e
jmp 0x72436
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b3c0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/prippa[P]Abstract-VM/source/main.cpp
// Function: main
int		main(int argc, char **argv)
{
	Base base;

	try
	{
		if (argc == 1)
			base.bs_read_from_input();
		else if (argc == 2)
			base.bs_read_from_file(argv[1]);
		else
		{
			std::cout << "Incorrect Use!" << std::endl;
			return (-1);
		}
		base.bs_valid_str();
		if (base.bs_is_valid_data())
			base.bs_run_calculator();
	}
	catch (const std::exception & e)
	{
		std::cout << "Line " <<  Exceptions::line << " : "<< e.what() << std::endl;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x138(%rbp), %rdi
callq 0x84c6
cmpl $0x2, %r14d
je 0x69a6
cmpl $0x1, %r14d
jne 0x69e2
leaq -0x138(%rbp), %rdi
callq 0x7c98
jmp 0x69b6
movq 0x8(%rbx), %rsi
leaq -0x138(%rbp), %rdi
callq 0x7d64
leaq -0x138(%rbp), %rdi
callq 0x7ee8
leaq -0x138(%rbp), %rdi
callq 0x82be
xorl %ebx, %ebx
testb %al, %al
je 0x6a2d
leaq -0x138(%rbp), %rdi
callq 0x82c8
jmp 0x6a2d
movq 0x265a7(%rip), %rbx     # 0x2cf90
leaq 0x1a614(%rip), %rsi     # 0x21004
movl $0xe, %edx
movq %rbx, %rdi
callq 0x63e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6350
movsbl %al, %esi
movq 0x26575(%rip), %rdi     # 0x2cf90
callq 0x6040
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %rax, %rdi
callq 0x6280
leaq -0x138(%rbp), %rdi
callq 0x85f6
movl %ebx, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x6ad7
movq %rbx, %rdi
callq 0x6180
movq %rax, %rbx
movq 0x2652b(%rip), %rdi     # 0x2cf90
leaq 0x1a5a7(%rip), %rsi     # 0x21013
movl $0x5, %edx
callq 0x63e0
leaq 0x268a3(%rip), %rax     # 0x2d320
movl (%rax), %esi
movq 0x2650a(%rip), %rdi     # 0x2cf90
callq 0x6270
movq %rax, %r14
leaq 0x1baae(%rip), %rsi     # 0x22543
movl $0x3, %edx
movq %rax, %rdi
callq 0x63e0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x6360
movq %rax, %rdi
callq 0x61c0
xorl %ebx, %ebx
callq 0x6520
jmp 0x6a2d
movq %rax, %rbx
jmp 0x6ad7
movq %rax, %rbx
callq 0x6520
leaq -0x138(%rbp), %rdi
callq 0x85f6
movq %rbx, %rdi
callq 0x6560
movq %rax, %rdi
callq 0x6af3
// File: /workspace/github_cpp_makefile_star2_O3/prippa[P]Abstract-VM/source/Base.class.cpp
// Function: Base::bs_read_from_file(char*)
void	Base::bs_read_from_file(char *file_name)
{
	std::ifstream ifs;

	ifs.open(file_name);
	if (!ifs.is_open())
		throw Exceptions::FileOpen(file_name);
	for (std::string line; std::getline(ifs, line);)
		str_.push_back(line);
	ifs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x250(%rbp), %r14
movq %r14, %rdi
callq 0x63d0
movq %r14, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x6240
leaq -0x1d8(%rbp), %rdi
callq 0x60d0
testb %al, %al
je 0x7e50
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x48(%rbp), %r15
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6350
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x6590
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7e1a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8864
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6070
incq 0x10(%rbx)
jmp 0x7dca
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x7e28
callq 0x6340
leaq -0x250(%rbp), %rdi
callq 0x60c0
leaq -0x250(%rbp), %rdi
callq 0x60e0
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x61d0
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %r15, %rsi
callq 0x6170
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x6b04
xorl %r15d, %r15d
leaq 0x2479a(%rip), %rsi     # 0x2c620
leaq -0x5e5(%rip), %rdx      # 0x78a8
movq %rbx, %rdi
callq 0x6550
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7eaa
callq 0x6340
testb %r15b, %r15b
jne 0x7eb4
jmp 0x7ed4
movq %rax, %r14
movq %rbx, %rdi
callq 0x62b0
jmp 0x7ed4
movq %rax, %r14
jmp 0x7ed4
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x7ed4
callq 0x6340
leaq -0x250(%rbp), %rdi
callq 0x60e0
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/prippa[P]Abstract-VM/source/Base.class.cpp
// Function: Base::bs_valid_str()
void	Base::bs_valid_str(void)
{
	for (auto i = str_.begin(); i != str_.end(); ++i)
	{
		try
		{
			if (!bs_parser(*i))
				break;
		}
		catch (const std::exception &e)
		{
			std::cout << e.what() << std::endl;
		}
		++Exceptions::line;
	}
	if (!is_exit_command_)
		throw Exceptions::NoExitCommandError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
cmpq %rdi, %r12
je 0x7f62
leaq 0x25418(%rip), %r13     # 0x2d320
movq 0x25081(%rip), %r14     # 0x2cf90
leaq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x7fbe
testb %al, %al
je 0x7f62
incl (%r13)
movq (%r12), %r12
cmpq %rbx, %r12
jne 0x7f0f
jmp 0x7f62
movq %rax, %r15
cmpl $0x1, %edx
jne 0x7fad
movq %r15, %rdi
callq 0x6180
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x6360
movq %rax, %rdi
callq 0x61c0
callq 0x6520
jmp 0x7f20
cmpb $0x0, 0x19(%rbx)
je 0x7f77
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x61d0
leaq 0x246c8(%rip), %rcx     # 0x2c650
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x246e2(%rip), %rsi     # 0x2c678
movq 0x25033(%rip), %rdx     # 0x2cfd0
movq %rax, %rdi
callq 0x6550
movq %rax, %r15
callq 0x6520
movq %r15, %rdi
callq 0x6560
movq %rax, %rdi
callq 0x6af3
nop
// File: /workspace/github_cpp_makefile_star2_O3/prippa[P]Abstract-VM/source/Base.class.cpp
// Function: Base::bs_run_calculator()
void	Base::bs_run_calculator(void)
{
	Exceptions::line = 1;
	for (auto i = str_.begin(); (i != str_.end() && is_exit_command_); ++i)
	{
		if (std::regex_match((*i).c_str(), result_, cmd_)
			|| std::regex_match((*i).c_str(), result_, cmd_with_value_))
			cmd_executor_.ce_execute_command(*this);
		++Exceptions::line;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x25040(%rip), %rax     # 0x2d320
movl $0x1, (%rax)
movq (%rdi), %r13
cmpq %rdi, %r13
je 0x8382
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x60(%rdi), %r15
leaq 0x80(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0xb8(%rdi), %rax
movq %rax, -0x38(%rbp)
cmpb $0x0, 0x19(%rbx)
je 0x8382
movq 0x10(%r13), %r12
movq %r12, %rdi
callq 0x61a0
leaq (%rax,%r12), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x8950
testb %al, %al
jne 0x8364
movq 0x10(%r13), %r12
movq %r12, %rdi
callq 0x61a0
leaq (%rax,%r12), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq -0x30(%rbp), %rcx
xorl %r8d, %r8d
callq 0x8950
testb %al, %al
je 0x8370
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x1f3ec
leaq 0x24fa9(%rip), %rax     # 0x2d320
incl (%rax)
movq (%r13), %r13
cmpq %rbx, %r13
jne 0x8313
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/prippa[P]Abstract-VM/source/Factory.class.cpp
// Function: FactoryClass::Factory::createDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
IOperand const	*FactoryClass::Factory::createDouble(std::string const & value) const
{
	long double num = std::stold(value);

	if (num > DBL_MAX)
		throw Exceptions::OverflowError("double");
	else if (num < -DBL_MAX)
		throw Exceptions::UnderflowError("double");
	else
		return (new Operand<double>(SCD(num)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq (%rsi), %rbx
callq 0x6060
movq %rax, %r14
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x40(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6530
cmpq %rbx, (%r15)
je 0x160fb
movl (%r14), %eax
testl %eax, %eax
je 0x160a9
cmpl $0x22, %eax
jne 0x160ac
fstp %st(0)
leaq 0xc345(%rip), %rdi      # 0x223e9
callq 0x64a0
movl %r12d, (%r14)
fldl 0xc306(%rip)            # 0x223b8
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
ja 0x16109
fldl 0xc300(%rip)            # 0x223c0
fucompi %st(1), %st
fstpt -0x54(%rbp)
ja 0x16161
movl $0x38, %edi
callq 0x6370
movq %rax, %r14
fldt -0x54(%rbp)
fstpl -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movq %rax, %rdi
callq 0x169ce
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
leaq 0xc2e5(%rip), %rdi      # 0x223e9
callq 0x6220
fstp %st(0)
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xc2a9(%rip), %rsi      # 0x223d0
leaq 0xc2a8(%rip), %rdx      # 0x223d6
leaq -0x40(%rbp), %rdi
callq 0x16c24
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x6e4a
xorl %r12d, %r12d
leaq 0x16540(%rip), %rsi     # 0x2c690
leaq -0xe7b3(%rip), %rdx     # 0x79a4
movq %r14, %rdi
callq 0x6550
jmp 0x161b5
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xc253(%rip), %rsi      # 0x223d0
leaq 0xc252(%rip), %rdx      # 0x223d6
leaq -0x40(%rbp), %rdi
callq 0x16c24
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x6f60
xorl %r12d, %r12d
leaq 0x16502(%rip), %rsi     # 0x2c6a8
leaq -0xe799(%rip), %rdx     # 0x7a14
movq %r14, %rdi
callq 0x6550
jmp 0x161b9
jmp 0x161d1
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x161ca
callq 0x6340
testb %r12b, %r12b
jne 0x161d4
jmp 0x161f7
movq %rax, %rbx
movq %r14, %rdi
callq 0x62b0
jmp 0x161f7
movq %rax, %rbx
movq %r14, %rdi
callq 0x6340
jmp 0x161f7
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x161f7
movl %r12d, (%r14)
movq %rbx, %rdi
callq 0x6560
nop