LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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*>>::next_byte_in_range(std::initializer_list<int>)
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
    {
        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
        add(current);

        for (auto range = ranges.begin(); range != ranges.end(); ++range)
        {
            get();
            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
            {
                add(current);
            }
            else
            {
                error_message = "invalid string: ill-formed UTF-8 byte";
                return false;
            }
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x6, %rdx
ja 0x678d9
movq %rdx, %r13
movl $0x54, %eax
btq %rdx, %rax
jae 0x678d9
movq %rsi, %r14
movq %rdi, %rbx
movsbl 0x14(%rdi), %esi
leaq 0x50(%rdi), %r15
movq %r15, %rdi
callq 0x1b480
testq %r13, %r13
sete %r12b
je 0x678c3
leaq (%r14,%r13,4), %r13
movq %rbx, %rdi
callq 0x1c1f4
movl 0x14(%rbx), %eax
cmpl %eax, (%r14)
jg 0x678b4
cmpl 0x4(%r14), %eax
leaq 0x4(%r14), %r14
setle %cl
testb %cl, %cl
je 0x678b8
movsbl %al, %esi
movq %r15, %rdi
callq 0x1b480
addq $0x4, %r14
cmpq %r13, %r14
sete %r12b
jne 0x6787b
jmp 0x678c3
xorl %ecx, %ecx
jmp 0x67896
leaq 0x1aa6d(%rip), %rax     # 0x8232c
movq %rax, 0x70(%rbx)
andb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ab9d(%rip), %rdi     # 0x8247d
leaq 0x197f8(%rip), %rsi     # 0x810df
leaq 0x1abce(%rip), %rcx     # 0x824bc
movl $0x1d64, %edx           # imm = 0x1D64
callq 0x1b320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x686b0
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 0x6e0a8
leaq 0x433bf(%rip), %rsi     # 0xaba98
leaq 0x556(%rip), %rdx       # 0x68c36
movq %r14, %rdi
callq 0x1b8b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68773
leaq 0x1ada3(%rip), %r14     # 0x834ca
leaq -0x38(%rbp), %r15
movzbl (%r13), %ecx
cmpl $0x1f, %ecx
ja 0x68760
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 0x6876b
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x1b480
incq %r13
cmpq %r12, %r13
jne 0x6872b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x68787
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x40(%rbp), %rdi
je 0x68798
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x665a6
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 0x665a6
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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_object(unsigned long)
bool start_object(std::size_t len)
    {
        // check callback for object start
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
        keep_stack.push_back(keep);

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

        // check object 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 object 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, -0x38(%rbp)
movb $0x0, -0x68(%rbp)
cmpq $0x0, 0x90(%rdi)
je 0x69f54
movq %rsi, %r15
movq %rdi, %rbx
addq $0x80, %rdi
leaq 0xa8(%rbx), %rcx
leaq -0x38(%rbp), %r14
leaq -0x68(%rbp), %rdx
movq %r14, %rsi
callq *0x98(%rbx)
leaq 0x20(%rbx), %rdi
movzbl %al, %esi
callq 0x699fe
movb $0x1, (%r14)
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x6a7d8
movb %al, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x69ea1
movq %rdx, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x69eae
leaq 0x8(%rbx), %rdi
leaq -0x40(%rbp), %rdx
callq 0x6afe0
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
testq %rax, %rax
sete %cl
cmpq $-0x1, %r15
sete %dl
orb %cl, %dl
jne 0x69ee5
movzbl (%rax), %eax
movl $0x1, %ecx
cmpq $0x2, %rax
ja 0x69ee0
leaq 0x1a034(%rip), %rcx     # 0x83f10
movq (%rcx,%rax,8), %rcx
cmpq %r15, %rcx
jb 0x69ef2
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b250
movq %rax, %r14
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x6ad07
leaq 0x18a63(%rip), %rsi     # 0x82975
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x6ac8b
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x38(%rbp), %rdx
movq %r14, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x6aaee
xorl %r15d, %r15d
leaq 0x41a93(%rip), %rsi     # 0xab9d8
leaq -0x1316(%rip), %rdx     # 0x68c36
movq %r14, %rdi
callq 0x1b8b0
callq 0x1b1b0
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x69f76
callq 0x1b4d0
jmp 0x69f76
movq %rax, %rbx
movb $0x1, %r15b
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x69f90
callq 0x1b4d0
jmp 0x69f90
movq %rax, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
je 0x69f9d
movq %r14, %rdi
callq 0x1b3c0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x38(%rbp)
movb $0x2, -0x68(%rbp)
cmpq $0x0, 0x90(%rdi)
je 0x6a3bc
movq %rsi, %r15
movq %rdi, %rbx
addq $0x80, %rdi
leaq 0xa8(%rbx), %rcx
leaq -0x38(%rbp), %r14
leaq -0x68(%rbp), %rdx
movq %r14, %rsi
callq *0x98(%rbx)
leaq 0x20(%rbx), %rdi
movzbl %al, %esi
callq 0x699fe
movb $0x2, (%r14)
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x6a7d8
movb %al, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x6a309
movq %rdx, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x6a316
leaq 0x8(%rbx), %rdi
leaq -0x40(%rbp), %rdx
callq 0x6afe0
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
testq %rax, %rax
sete %cl
cmpq $-0x1, %r15
sete %dl
orb %cl, %dl
jne 0x6a34d
movzbl (%rax), %eax
movl $0x1, %ecx
cmpq $0x2, %rax
ja 0x6a348
leaq 0x19bcc(%rip), %rcx     # 0x83f10
movq (%rcx,%rax,8), %rcx
cmpq %r15, %rcx
jb 0x6a35a
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b250
movq %rax, %r14
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x6ad07
leaq 0x18bf3(%rip), %rsi     # 0x82f6d
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x6cc09
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x38(%rbp), %rdx
movq %r14, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x6aaee
xorl %r15d, %r15d
leaq 0x4162b(%rip), %rsi     # 0xab9d8
leaq -0x177e(%rip), %rdx     # 0x68c36
movq %r14, %rdi
callq 0x1b8b0
callq 0x1b1b0
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a3de
callq 0x1b4d0
jmp 0x6a3de
movq %rax, %rbx
movb $0x1, %r15b
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a3f8
callq 0x1b4d0
jmp 0x6a3f8
movq %rax, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
je 0x6a405
movq %r14, %rdi
callq 0x1b3c0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq -0x8(%rax), %rcx
testq %rcx, %rcx
je 0x6a493
subq 0x8(%rbx), %rax
shrq $0x3, %rax
decl %eax
movl %eax, -0x20(%rbp)
movb $0x3, -0x19(%rbp)
cmpq $0x0, 0x90(%rbx)
je 0x6a554
leaq 0x80(%rbx), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x19(%rbp), %rdx
callq *0x98(%rbx)
movl %eax, %r14d
testb %al, %al
jne 0x6a496
leaq 0xa8(%rbx), %rsi
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x6b1d6
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
movq %r15, %rsi
callq 0x68c64
movq %r15, %rdi
callq 0x65da4
jmp 0x6a496
movb $0x1, %r14b
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
cmpq %rax, %rcx
je 0x6a516
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 0x6a535
leaq -0x8(%rax), %rdi
movq %rdi, 0x10(%rbx)
subl $0x1, %esi
movl %esi, 0x38(%rbx)
jae 0x6a4e0
movl $0x3f, 0x38(%rbx)
addq $-0x8, %rdx
movq %rdx, 0x30(%rbx)
cmpq %rdi, %rcx
sete %cl
orb %cl, %r14b
jne 0x6a509
movq -0x10(%rax), %rax
cmpb $0x2, (%rax)
jne 0x6a509
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
addq $-0x10, %rdi
movq %rdi, 0x8(%rax)
callq 0x65da4
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x185ce(%rip), %rdi     # 0x82aeb
leaq 0x16bbb(%rip), %rsi     # 0x810df
leaq 0x18a59(%rip), %rcx     # 0x82f84
movl $0x1bb3, %edx           # imm = 0x1BB3
callq 0x1b320
leaq 0x18451(%rip), %rdi     # 0x8298d
leaq 0x16b9c(%rip), %rsi     # 0x810df
leaq 0x18a3a(%rip), %rcx     # 0x82f84
movl $0x1bb4, %edx           # imm = 0x1BB4
callq 0x1b320
callq 0x1b1b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c4ba
movb $0x3, (%r14)
movq %rbx, %rdi
callq 0x6bba6
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x665a6
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, %rbx
addq $0x8, %rdi
movzbl (%rbx), %esi
callq 0x6c4ba
movb $0x7, (%rbx)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x665a6
movq %rax, %rdi
callq 0x3ec84
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c4ba
movb $0x4, (%rbx)
movzbl %r14b, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x665a6
movq %rax, %rdi
callq 0x3ec84
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c4ba
movb $0x5, (%rbx)
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x665a6
movq %rax, %rdi
callq 0x3ec84
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 -0x58(%rbp), %rsi
movb $0x1, (%rsi)
callq 0x6e828
movq %rax, -0x38(%rbp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x6e48d
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x6e49a
leaq 0x8(%r14), %rdi
leaq -0x38(%rbp), %rdx
callq 0x6e934
cmpq $-0x1, %r15
je 0x6e4c6
movq 0x10(%r14), %rax
movq -0x8(%rax), %rax
movzbl (%rax), %eax
movl $0x1, %ecx
cmpq $0x2, %rax
ja 0x6e4c1
leaq 0x15a53(%rip), %rcx     # 0x83f10
movq (%rcx,%rax,8), %rcx
cmpq %r15, %rcx
jb 0x6e4d3
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b250
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x6ad07
leaq 0x14482(%rip), %rsi     # 0x82975
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x6ac8b
movq 0x10(%r14), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x6aaee
xorl %r15d, %r15d
leaq 0x3d4b2(%rip), %rsi     # 0xab9d8
leaq -0x58f7(%rip), %rdx     # 0x68c36
movq %rbx, %rdi
callq 0x1b8b0
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e552
callq 0x1b4d0
jmp 0x6e552
movq %rax, %r14
movb $0x1, %r15b
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e56c
callq 0x1b4d0
jmp 0x6e56c
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x6e579
movq %rbx, %rdi
callq 0x1b3c0
movq %r14, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e5a5
movq -0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x6e5c4
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rbp
retq
leaq 0x1453f(%rip), %rdi     # 0x82aeb
leaq 0x12b2c(%rip), %rsi     # 0x810df
leaq 0x1522a(%rip), %rcx     # 0x837e4
movl $0x1aa9, %edx           # imm = 0x1AA9
callq 0x1b320
leaq 0x144ce(%rip), %rdi     # 0x82a99
leaq 0x12b0d(%rip), %rsi     # 0x810df
leaq 0x1520b(%rip), %rcx     # 0x837e4
movl $0x1aaa, %edx           # imm = 0x1AAA
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e616
movq -0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x6e635
movq %rdi, %rbx
movq 0x8(%rax), %rdi
callq 0x6c3fe
movq %rax, 0x20(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x144ce(%rip), %rdi     # 0x82aeb
leaq 0x12abb(%rip), %rsi     # 0x810df
leaq 0x15233(%rip), %rcx     # 0x8385e
movl $0x1a9f, %edx           # imm = 0x1A9F
callq 0x1b320
leaq 0x1445d(%rip), %rdi     # 0x82a99
leaq 0x12a9c(%rip), %rsi     # 0x810df
leaq 0x15214(%rip), %rcx     # 0x8385e
movl $0x1aa0, %edx           # imm = 0x1AA0
callq 0x1b320
// File: /workspace/github_cpp_makefile_star2_O1/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 -0x58(%rbp), %rsi
movb $0x2, (%rsi)
callq 0x6e828
movq %rax, -0x38(%rbp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x6e68b
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x6e698
leaq 0x8(%r14), %rdi
leaq -0x38(%rbp), %rdx
callq 0x6e934
cmpq $-0x1, %r15
je 0x6e6c4
movq 0x10(%r14), %rax
movq -0x8(%rax), %rax
movzbl (%rax), %eax
movl $0x1, %ecx
cmpq $0x2, %rax
ja 0x6e6bf
leaq 0x15855(%rip), %rcx     # 0x83f10
movq (%rcx,%rax,8), %rcx
cmpq %r15, %rcx
jb 0x6e6d1
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b250
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x6ad07
leaq 0x1487c(%rip), %rsi     # 0x82f6d
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x6cc09
movq 0x10(%r14), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x6aaee
xorl %r15d, %r15d
leaq 0x3d2b4(%rip), %rsi     # 0xab9d8
leaq -0x5af5(%rip), %rdx     # 0x68c36
movq %rbx, %rdi
callq 0x1b8b0
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e750
callq 0x1b4d0
jmp 0x6e750
movq %rax, %r14
movb $0x1, %r15b
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e76a
callq 0x1b4d0
jmp 0x6e76a
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x6e777
movq %rbx, %rdi
callq 0x1b3c0
movq %r14, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e7a3
movq -0x8(%rax), %rcx
cmpb $0x2, (%rcx)
jne 0x6e7c2
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rbp
retq
leaq 0x14341(%rip), %rdi     # 0x82aeb
leaq 0x1292e(%rip), %rsi     # 0x810df
leaq 0x15123(%rip), %rcx     # 0x838db
movl $0x1abf, %edx           # imm = 0x1ABF
callq 0x1b320
leaq 0x1518b(%rip), %rdi     # 0x83954
leaq 0x1290f(%rip), %rsi     # 0x810df
leaq 0x15104(%rip), %rcx     # 0x838db
movl $0x1ac0, %edx           # imm = 0x1AC0
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpb $0x0, (%rdi)
jne 0x73447
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x1b510
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x665a6
cmpb $0x1, (%r14)
jne 0x73473
movq 0x8(%r14), %rdi
leaq -0x40(%rbp), %rdx
movq $0x0, (%rdx)
movq %rbx, %rsi
callq 0x7358c
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 0x6c292
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x11543(%rip), %rsi     # 0x849d9
leaq -0x40(%rbp), %rdi
callq 0x73501
movb $0x1, %r15b
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
movq %r14, %rcx
callq 0x6c06a
xorl %r15d, %r15d
leaq 0x38598(%rip), %rsi     # 0xaba58
leaq -0xa891(%rip), %rdx     # 0x68c36
movq %rbx, %rdi
callq 0x1b8b0
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x734ec
callq 0x1b4d0
jmp 0x734ec
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x734f9
movq %rbx, %rdi
callq 0x1b3c0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x84d4
cmpl $0x2, %r14d
je 0x69b6
cmpl $0x1, %r14d
jne 0x69f2
leaq -0x138(%rbp), %rdi
callq 0x7ca8
jmp 0x69c6
movq 0x8(%rbx), %rsi
leaq -0x138(%rbp), %rdi
callq 0x7d74
leaq -0x138(%rbp), %rdi
callq 0x7efc
leaq -0x138(%rbp), %rdi
callq 0x82cc
xorl %ebx, %ebx
testb %al, %al
je 0x6a3d
leaq -0x138(%rbp), %rdi
callq 0x82d6
jmp 0x6a3d
movq 0x2659f(%rip), %rbx     # 0x2cf98
leaq 0x1a604(%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 0x2656d(%rip), %rdi     # 0x2cf98
callq 0x6040
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %rax, %rdi
callq 0x6280
leaq -0x138(%rbp), %rdi
callq 0x8604
movl %ebx, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x6ae7
movq %rbx, %rdi
callq 0x6180
movq %rax, %rbx
movq 0x26523(%rip), %rdi     # 0x2cf98
leaq 0x1a597(%rip), %rsi     # 0x21013
movl $0x5, %edx
callq 0x63e0
leaq 0x26893(%rip), %rax     # 0x2d320
movl (%rax), %esi
movq 0x26502(%rip), %rdi     # 0x2cf98
callq 0x6270
movq %rax, %r14
leaq 0x1ba9e(%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 0x6a3d
movq %rax, %rbx
jmp 0x6ae7
movq %rax, %rbx
callq 0x6520
leaq -0x138(%rbp), %rdi
callq 0x8604
movq %rbx, %rdi
callq 0x6560
movq %rax, %rdi
callq 0x6b03
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7e60
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 0x7e2a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8872
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6070
incq 0x10(%rbx)
jmp 0x7dda
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x7e38
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 0x6b14
xorl %r15d, %r15d
leaq 0x2475a(%rip), %rsi     # 0x2c5f0
leaq -0x5e5(%rip), %rdx      # 0x78b8
movq %rbx, %rdi
callq 0x6550
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7ec2
callq 0x6340
jmp 0x7ec2
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x7ee7
movq %rbx, %rdi
callq 0x62b0
jmp 0x7ee7
movq %rax, %r14
jmp 0x7ee7
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x7ee7
callq 0x6340
leaq -0x250(%rbp), %rdi
callq 0x60e0
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7f76
leaq 0x25404(%rip), %r13     # 0x2d320
movq 0x25075(%rip), %r14     # 0x2cf98
leaq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x7fd2
testb %al, %al
je 0x7f76
incl (%r13)
movq (%r12), %r12
cmpq %rbx, %r12
jne 0x7f23
jmp 0x7f76
movq %rax, %r15
cmpl $0x1, %edx
jne 0x7fc1
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 0x7f34
cmpb $0x0, 0x19(%rbx)
je 0x7f8b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x61d0
leaq 0x24684(%rip), %rcx     # 0x2c620
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x2469e(%rip), %rsi     # 0x2c648
movq 0x25027(%rip), %rdx     # 0x2cfd8
movq %rax, %rdi
callq 0x6550
movq %rax, %r15
callq 0x6520
movq %r15, %rdi
callq 0x6560
movq %rax, %rdi
callq 0x6b03
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25032(%rip), %rax     # 0x2d320
movl $0x1, (%rax)
movq (%rdi), %r13
cmpq %rdi, %r13
je 0x8390
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 0x8390
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 0x8959
testb %al, %al
jne 0x8372
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 0x8959
testb %al, %al
je 0x837e
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x1f43a
leaq 0x24f9b(%rip), %rax     # 0x2d320
incl (%rax)
movq (%r13), %r13
cmpq %rbx, %r13
jne 0x8321
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x160af
movl (%r14), %eax
testl %eax, %eax
je 0x1605d
cmpl $0x22, %eax
jne 0x16060
fstp %st(0)
leaq 0xc391(%rip), %rdi      # 0x223e9
callq 0x64a0
movl %r12d, (%r14)
fldl 0xc352(%rip)            # 0x223b8
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
ja 0x160bd
fldl 0xc34c(%rip)            # 0x223c0
fucompi %st(1), %st
fstpt -0x54(%rbp)
ja 0x16116
movl $0x38, %edi
callq 0x6370
movq %rax, %r14
fldt -0x54(%rbp)
fstpl -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movq %rax, %rdi
callq 0x16996
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
leaq 0xc331(%rip), %rdi      # 0x223e9
callq 0x6220
fstp %st(0)
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xc2f4(%rip), %rsi      # 0x223d0
leaq 0xc2f3(%rip), %rdx      # 0x223d6
leaq -0x40(%rbp), %rdi
callq 0x16be2
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x6e5a
xorl %r15d, %r15d
leaq 0x1655b(%rip), %rsi     # 0x2c660
leaq -0xe758(%rip), %rdx     # 0x79b4
movq %r14, %rdi
callq 0x6550
jmp 0x1616b
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xc29d(%rip), %rsi      # 0x223d0
leaq 0xc29c(%rip), %rdx      # 0x223d6
leaq -0x40(%rbp), %rdi
callq 0x16be2
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x6f70
xorl %r15d, %r15d
leaq 0x1651c(%rip), %rsi     # 0x2c678
leaq -0xe73f(%rip), %rdx     # 0x7a24
movq %r14, %rdi
callq 0x6550
jmp 0x1616f
jmp 0x16182
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x16188
callq 0x6340
jmp 0x16188
movq %rax, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
je 0x161b0
movq %r14, %rdi
callq 0x62b0
jmp 0x161b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x6340
jmp 0x161b0
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x161b0
movl %r12d, (%r14)
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O1/prippa[P]Abstract-VM/source/Factory.class.cpp
// Function: FactoryClass::Factory::createFloat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
IOperand const	*FactoryClass::Factory::createFloat(std::string const & value) const
{
	long double num = std::stold(value);

	if (num > FLT_MAX)
		throw Exceptions::OverflowError("float");
	else if (num < -FLT_MAX)
		throw Exceptions::UnderflowError("float");
	else
		return (new Operand<float>(SCF(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 -0x48(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6530
cmpq %rbx, (%r15)
je 0x1625b
movl (%r14), %eax
testl %eax, %eax
je 0x16209
cmpl $0x22, %eax
jne 0x1620c
fstp %st(0)
leaq 0xc1e5(%rip), %rdi      # 0x223e9
callq 0x64a0
movl %r12d, (%r14)
flds 0xc1b6(%rip)            # 0x223c8
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
ja 0x16269
flds 0xc1ac(%rip)            # 0x223cc
fucompi %st(1), %st
fstpt -0x54(%rbp)
ja 0x162c2
movl $0x38, %edi
callq 0x6370
movq %rax, %r14
fldt -0x54(%rbp)
fstps -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movq %rax, %rdi
callq 0x169f0
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
leaq 0xc185(%rip), %rdi      # 0x223e9
callq 0x6220
fstp %st(0)
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xc14f(%rip), %rsi      # 0x223d7
leaq 0xc14d(%rip), %rdx      # 0x223dc
leaq -0x48(%rbp), %rdi
callq 0x16be2
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x6e5a
xorl %r15d, %r15d
leaq 0x163af(%rip), %rsi     # 0x2c660
leaq -0xe904(%rip), %rdx     # 0x79b4
movq %r14, %rdi
callq 0x6550
jmp 0x16317
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xc0f8(%rip), %rsi      # 0x223d7
leaq 0xc0f6(%rip), %rdx      # 0x223dc
leaq -0x48(%rbp), %rdi
callq 0x16be2
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x6f70
xorl %r15d, %r15d
leaq 0x16370(%rip), %rsi     # 0x2c678
leaq -0xe8eb(%rip), %rdx     # 0x7a24
movq %r14, %rdi
callq 0x6550
jmp 0x1631b
jmp 0x1632e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x16334
callq 0x6340
jmp 0x16334
movq %rax, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1635c
movq %r14, %rdi
callq 0x62b0
jmp 0x1635c
movq %rax, %rbx
movq %r14, %rdi
callq 0x6340
jmp 0x1635c
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1635c
movl %r12d, (%r14)
movq %rbx, %rdi
callq 0x6560