LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::detail::Opt::getHelpColumns() const
auto getHelpColumns() const -> std::vector<HelpColumns> {
            std::ostringstream oss;
            bool first = true;
            for( auto const &opt : m_optNames ) {
                if (first)
                    first = false;
                else
                    oss << ", ";
                oss << opt;
            }
            if( !m_hint.empty() )
                oss << " <" << m_hint << ">";
            return { { oss.str(), m_description } };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
leaq -0x1f0(%rbp), %r15
movq %r15, %rdi
callq 0x24740
movq 0x60(%r14), %r12
movq 0x68(%r14), %rbx
movb $0x1, %al
leaq 0x2dfb0(%rip), %r13     # 0x7418b
cmpq %rbx, %r12
je 0x46202
testb $0x1, %al
jne 0x461ef
movq %r15, %rdi
movq %r13, %rsi
callq 0x24570
movq %r15, %rdi
movq %r12, %rsi
callq 0x24510
addq $0x20, %r12
xorl %eax, %eax
jmp 0x461db
cmpq $0x0, 0x28(%r14)
je 0x46237
leaq 0x2f9b7(%rip), %rsi     # 0x75bc7
leaq -0x1f0(%rbp), %rdi
callq 0x24570
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x24510
leaq 0x2e712(%rip), %rsi     # 0x74941
movq %rax, %rdi
callq 0x24570
leaq -0x1e8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x24830
leaq -0x58(%rbp), %rdi
addq $0x40, %r14
movq %r14, %rsi
callq 0x24760
leaq -0x78(%rbp), %rsi
pushq $0x1
popq %rdx
leaq -0x29(%rbp), %rcx
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x46310
leaq -0x78(%rbp), %rdi
callq 0x462f0
leaq -0x1f0(%rbp), %rdi
callq 0x24130
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x462f0
jmp 0x462bb
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x24ad8
jmp 0x462bb
jmp 0x462b8
jmp 0x462b8
movq %rax, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x24130
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::MatchExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Catch::Matchers::Impl::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&>::streamReconstructedExpression(std::ostream&) const
void streamReconstructedExpression( std::ostream &os ) const override {
            auto matcherAsString = m_matcher.toString();
            os << Catch::Detail::stringify( m_arg ) << ' ';
            if( matcherAsString == Detail::unprintableString )
                os << m_matcherString;
            else
                os << matcherAsString;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2bdcc
movq 0x10(%r14), %rsi
leaq -0x50(%rbp), %rdi
callq 0x33ca4
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x24510
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x24670
leaq -0x50(%rbp), %rdi
callq 0x24ad8
leaq 0x65f10(%rip), %rsi     # 0xaedd8
leaq -0x30(%rbp), %rdi
callq 0x3e788
testb %al, %al
je 0x48ee6
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29ecc
jmp 0x48ef2
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x24510
leaq -0x30(%rbp), %rdi
callq 0x24ad8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x48f06
movq %rax, %rbx
jmp 0x48f17
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ad8
leaq -0x30(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/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 0x24400
leaq -0x1d0(%rbp), %rdi
movq %r14, %rsi
callq 0x24510
leaq -0x1e0(%rbp), %rdi
movq %r15, %rsi
callq 0x24340
movq -0x1e0(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1c0(%rbp,%rax)
je 0x49803
leaq 0x2c86f(%rip), %rsi     # 0x76032
leaq -0x38(%rbp), %rdi
movq %r14, %rdx
callq 0x3e5a5
leaq 0x2c870(%rip), %rdx     # 0x76046
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3e57c
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x496de
leaq -0x58(%rbp), %rdi
callq 0x24ad8
leaq -0x38(%rbp), %rdi
callq 0x24ad8
jmp 0x49827
andq $0x0, 0x8(%rbx)
leaq 0x62ea9(%rip), %rax     # 0xac6b8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
leaq -0x1e0(%rbp), %rdi
callq 0x24460
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x24ad8
jmp 0x49855
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x24ad8
jmp 0x49865
jmp 0x49862
movq %rax, %rbx
leaq -0x1e0(%rbp), %rdi
callq 0x24460
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_2::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline OutStringType concat(Args && ... args)
{
    OutStringType str;
    str.reserve(concat_length(args...));
    concat_into(str, std::forward<Args>(args)...);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r15
movq %rsi, %r12
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq 0x8(%r12), %rsi
addq 0x8(%rcx), %rsi
callq 0x24810
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x6194f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/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()
char_int_type get()
    {
        ++position.chars_read_total;
        ++position.chars_read_current_line;

        if (next_unget)
        {
            // just reset the next_unget variable and work with current
            next_unget = false;
        }
        else
        {
            current = ia.get_character();
        }

        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
        {
            token_string.push_back(std::char_traits<char_type>::to_char_type(current));
        }

        if (current == '\n')
        {
            ++position.lines_read;
            position.chars_read_current_line = 0;
        }

        return current;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
incq 0x20(%rdi)
incq 0x28(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x628e0
movb $0x0, 0x18(%rbx)
movl 0x14(%rbx), %eax
jmp 0x628f5
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x62928
movzbl (%rcx), %eax
incq %rcx
movq %rcx, (%rbx)
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
je 0x62924
leaq 0x38(%rbx), %rdi
leaq -0x9(%rbp), %rsi
movb %al, (%rsi)
callq 0x52d3e
movl 0x14(%rbx), %eax
cmpl $0xa, %eax
jne 0x6291d
incq 0x30(%rbx)
andq $0x0, 0x28(%rbx)
pushq $0xa
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $-0x1
jmp 0x6291c
pushq $-0x1
popq %rax
jmp 0x628f2
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x62945
leaq 0x28(%rdi), %rcx
jmp 0x62952
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x62958
leaq 0x30(%rdi), %rcx
decq %rax
movq %rax, (%rcx)
cmpl $-0x1, 0x14(%rdi)
je 0x6296f
movq 0x40(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x62970
decq %rax
movq %rax, 0x40(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x16ca8(%rip), %rdi     # 0x79623
leaq 0x166dc(%rip), %rsi     # 0x7905e
leaq 0x16cb0(%rip), %rcx     # 0x79639
movl $0x21fc, %edx           # imm = 0x21FC
callq 0x24390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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_codepoint()
int get_codepoint()
    {
        // this function only makes sense after reading `\u`
        JSON_ASSERT(current == 'u');
        int codepoint = 0;

        const auto factors = { 12u, 8u, 4u, 0u };
        for (const auto factor : factors)
        {
            get();

            if (current >= '0' && current <= '9')
            {
                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
            }
            else if (current >= 'A' && current <= 'F')
            {
                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
            }
            else if (current >= 'a' && current <= 'f')
            {
                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
            }
            else
            {
                return -1;
            }
        }

        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
        return codepoint;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x75, 0x14(%rdi)
jne 0x62a6f
movq %rdi, %rbx
movaps 0x15f05(%rip), %xmm0    # 0x78900
movups %xmm0, -0x38(%rbp)
xorl %r12d, %r12d
pushq $-0x1
popq %r13
xorl %r14d, %r14d
cmpq $0x10, %r12
je 0x62a4f
movl -0x38(%rbp,%r12), %r15d
movq %rbx, %rdi
callq 0x628c0
movl 0x14(%rbx), %eax
leal -0x30(%rax), %edx
cmpl $0xa, %edx
jb 0x62a41
leal -0x41(%rax), %ecx
cmpl $0x5, %ecx
ja 0x62a34
addl $-0x37, %eax
jmp 0x62a3f
leal -0x61(%rax), %ecx
cmpl $0x5, %ecx
ja 0x62a6a
addl $-0x57, %eax
movl %eax, %edx
movl %r15d, %ecx
shll %cl, %edx
addl %edx, %r14d
addq $0x4, %r12
jmp 0x62a09
cmpl $0x10000, %r14d         # imm = 0x10000
jae 0x62a8e
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r13d, %r14d
jmp 0x62a58
leaq 0x17a18(%rip), %rdi     # 0x7a48e
leaq 0x165e1(%rip), %rsi     # 0x7905e
leaq 0x17a19(%rip), %rcx     # 0x7a49d
movl $0x1d35, %edx           # imm = 0x1D35
callq 0x24390
leaq 0x17af9(%rip), %rdi     # 0x7a58e
leaq 0x165c2(%rip), %rsi     # 0x7905e
leaq 0x179fa(%rip), %rcx     # 0x7a49d
movl $0x1d4f, %edx           # imm = 0x1D4F
callq 0x24390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
cmpq $0x6, %rdx
ja 0x62b30
movq %rdx, %rbx
pushq $0x54
popq %rax
btq %rdx, %rax
jae 0x62b30
movq %rsi, %r15
movq %rdi, %r14
movsbl 0x14(%rdi), %esi
leaq 0x50(%rdi), %r12
movq %r12, %rdi
callq 0x244e0
shlq $0x2, %rbx
testq %rbx, %rbx
je 0x62b21
movq %r14, %rdi
callq 0x628c0
movl 0x14(%r14), %eax
cmpl %eax, (%r15)
jg 0x62b16
cmpl 0x4(%r15), %eax
jg 0x62b16
movsbl %al, %esi
movq %r12, %rdi
callq 0x244e0
addq $0x8, %r15
addq $-0x8, %rbx
jmp 0x62ae5
leaq 0x1794b(%rip), %rax     # 0x7a468
movq %rax, 0x70(%r14)
testq %rbx, %rbx
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17a82(%rip), %rdi     # 0x7a5b9
leaq 0x16520(%rip), %rsi     # 0x7905e
leaq 0x17ab3(%rip), %rcx     # 0x7a5f8
movl $0x1d64, %edx           # imm = 0x1D64
callq 0x24390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x635d2
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
pushq $0x28
popq %rdi
callq 0x242b0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x68586
leaq 0x4a4cf(%rip), %rsi     # 0xadac8
leaq 0x37c(%rip), %rdx       # 0x6397c
movq %r14, %rdi
callq 0x248f0
// File: /workspace/github_cpp_makefile_star2_O2/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, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %r14
leaq -0x38(%rbp), %r15
pushq $0x9
popq %r12
cmpq %r14, %r13
je 0x63685
movzbl (%r13), %ecx
cmpl $0x1f, %ecx
ja 0x63675
movb $0x0, -0x30(%rbp)
andq $0x0, -0x38(%rbp)
movq %r15, %rdi
movq %r12, %rsi
leaq 0x17fa5(%rip), %rdx     # 0x7b606
xorl %eax, %eax
callq 0x24850
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24a10
jmp 0x63680
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x244e0
incq %r13
jmp 0x6363c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x63699
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r15
movq %rsi, %rdi
movl %r15d, %esi
callq 0x61454
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movl %r15d, %esi
callq 0x61454
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r15
movq %rdi, %r14
addq $0x80, %rdi
leaq 0x8(%r14), %rbx
movq 0x10(%r14), %rsi
subq 0x8(%r14), %rsi
shrq $0x3, %rsi
leaq 0xa8(%r14), %rcx
xorl %edx, %edx
callq 0x6522a
leaq 0x20(%r14), %rdi
movzbl %al, %esi
callq 0x64456
leaq -0x38(%rbp), %rsi
movb $0x1, (%rsi)
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x65256
leaq -0x60(%rbp), %rsi
movb %al, -0x8(%rsi)
movq %rdx, (%rsi)
movq %rbx, %rdi
callq 0x65464
movq 0x10(%r14), %rax
movq -0x8(%rax), %rdi
testq %rdi, %rdi
sete %al
cmpq $-0x1, %r15
sete %cl
orb %al, %cl
jne 0x64a81
callq 0x65488
cmpq %r15, %rax
jb 0x64a8e
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x242b0
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x6561e
leaq 0x16005(%rip), %rsi     # 0x7aab1
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x655b6
movq 0x10(%r14), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x654b8
xorl %r15d, %r15d
leaq 0x48f29(%rip), %rsi     # 0xada08
leaq -0x116a(%rip), %rdx     # 0x6397c
movq %rbx, %rdi
callq 0x248f0
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x24ad8
jmp 0x64b02
movq %rax, %r14
movb $0x1, %r15b
leaq -0x58(%rbp), %rdi
callq 0x24ad8
testb %r15b, %r15b
jne 0x64b15
jmp 0x64b1d
movq %rax, %r14
movq %rbx, %rdi
callq 0x24430
movq %r14, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r15
movq %rdi, %r14
addq $0x80, %rdi
leaq 0x8(%r14), %rbx
movq 0x10(%r14), %rsi
subq 0x8(%r14), %rsi
shrq $0x3, %rsi
leaq 0xa8(%r14), %rcx
pushq $0x2
popq %rdx
callq 0x6522a
leaq 0x20(%r14), %rdi
movzbl %al, %esi
callq 0x64456
leaq -0x38(%rbp), %rsi
movb $0x2, (%rsi)
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x65256
leaq -0x60(%rbp), %rsi
movb %al, -0x8(%rsi)
movq %rdx, (%rsi)
movq %rbx, %rdi
callq 0x65464
movq 0x10(%r14), %rax
movq -0x8(%rax), %rdi
testq %rdi, %rdi
sete %al
cmpq $-0x1, %r15
sete %cl
orb %al, %cl
jne 0x64dfe
callq 0x65488
cmpq %r15, %rax
jb 0x64e0b
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x242b0
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x6561e
leaq 0x16280(%rip), %rsi     # 0x7b0a9
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x675e8
movq 0x10(%r14), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x654b8
xorl %r15d, %r15d
leaq 0x48bac(%rip), %rsi     # 0xada08
leaq -0x14e7(%rip), %rdx     # 0x6397c
movq %rbx, %rdi
callq 0x248f0
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x24ad8
jmp 0x64e7f
movq %rax, %r14
movb $0x1, %r15b
leaq -0x58(%rbp), %rdi
callq 0x24ad8
testb %r15b, %r15b
jne 0x64e92
jmp 0x64e9a
movq %rax, %r14
movq %rbx, %rdi
callq 0x24430
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq -0x8(%rsi), %rcx
movb $0x1, %r14b
testq %rcx, %rcx
je 0x64f0b
leaq 0x80(%rbx), %rdi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
decl %esi
pushq $0x3
popq %rdx
callq 0x6522a
testb %al, %al
jne 0x64f0b
leaq 0xa8(%rbx), %rsi
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x65b54
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
movq %r14, %rsi
callq 0x639d0
movq %r14, %rdi
callq 0x60da8
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x64f62
movq 0x20(%rbx), %rcx
cmpq 0x30(%rbx), %rcx
jne 0x64f25
cmpl $0x0, 0x38(%rbx)
je 0x64f81
leaq 0x30(%rbx), %rdi
addq $-0x8, %rax
movq %rax, 0x10(%rbx)
callq 0x6484e
testb %r14b, %r14b
jne 0x64f57
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x64f57
movq -0x8(%rax), %rax
cmpb $0x2, (%rax)
jne 0x64f57
movq 0x8(%rax), %rdi
callq 0x67132
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15cbe(%rip), %rdi     # 0x7ac27
leaq 0x140ee(%rip), %rsi     # 0x7905e
leaq 0x16149(%rip), %rcx     # 0x7b0c0
movl $0x1bb3, %edx           # imm = 0x1BB3
callq 0x24390
leaq 0x15b41(%rip), %rdi     # 0x7aac9
leaq 0x140cf(%rip), %rsi     # 0x7905e
leaq 0x1612a(%rip), %rcx     # 0x7b0c0
movl $0x1bb4, %edx           # imm = 0x1BB4
callq 0x24390
// File: /workspace/github_cpp_makefile_star2_O2/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>::basic_json(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(basic_json&& other) noexcept
        : json_base_class_t(std::move(other)),
          m_type(std::move(other.m_type)),
          m_value(std::move(other.m_value))
    {
        // check that passed value is valid
        other.assert_invariant(false); // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)

        // invalidate payload
        other.m_type = value_t::null;
        other.m_value = {};

        set_parents();
        assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb (%rsi), %al
movb %al, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x61454
movb $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x61454
// File: /workspace/github_cpp_makefile_star2_O2/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 0x66eca
movb $0x3, (%r14)
movq %rbx, %rdi
callq 0x6656c
movq %rax, 0x8(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x61454
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x66eca
movb $0x7, (%rbx)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x61454
movq %rax, %rdi
callq 0x3dcad
// File: /workspace/github_cpp_makefile_star2_O2/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 0x66eca
movb $0x4, (%rbx)
movzbl %r14b, %eax
movq %rax, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x61454
movq %rax, %rdi
callq 0x3dcad
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x66eca
movb $0x5, (%rbx)
movq %r14, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x61454
movq %rax, %rdi
callq 0x3dcad
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x66eca
movb $0x6, (%rbx)
movq %r14, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x61454
movq %rax, %rdi
callq 0x3dcad
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8(%rdi), %rbx
leaq -0x38(%rbp), %rsi
movb $0x1, (%rsi)
callq 0x690a8
leaq -0x58(%rbp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x6918c
cmpq $-0x1, %r15
je 0x68d02
movq 0x10(%r14), %rax
movq -0x8(%rax), %rdi
callq 0x65488
cmpq %r15, %rax
jb 0x68d0f
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x242b0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x6561e
leaq 0x11d84(%rip), %rsi     # 0x7aab1
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x655b6
movq 0x10(%r14), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x654b8
xorl %r15d, %r15d
leaq 0x44ca8(%rip), %rsi     # 0xada08
leaq -0x53eb(%rip), %rdx     # 0x6397c
movq %rbx, %rdi
callq 0x248f0
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x24ad8
jmp 0x68d83
movq %rax, %r14
movb $0x1, %r15b
leaq -0x38(%rbp), %rdi
callq 0x24ad8
testb %r15b, %r15b
jne 0x68d96
jmp 0x68d9e
movq %rax, %r14
movq %rbx, %rdi
callq 0x24430
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/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 0x68dc9
movq -0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x68de8
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rbp
retq
leaq 0x11e57(%rip), %rdi     # 0x7ac27
leaq 0x10287(%rip), %rsi     # 0x7905e
leaq 0x12b42(%rip), %rcx     # 0x7b920
movl $0x1aa9, %edx           # imm = 0x1AA9
callq 0x24390
leaq 0x11de6(%rip), %rdi     # 0x7abd5
leaq 0x10268(%rip), %rsi     # 0x7905e
leaq 0x12b23(%rip), %rcx     # 0x7b920
movl $0x1aaa, %edx           # imm = 0x1AAA
callq 0x24390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x68e3a
movq -0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x68e59
movq %rdi, %rbx
movq 0x8(%rax), %rdi
callq 0x66e26
movq %rax, 0x20(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x11de6(%rip), %rdi     # 0x7ac27
leaq 0x10216(%rip), %rsi     # 0x7905e
leaq 0x12b4b(%rip), %rcx     # 0x7b99a
movl $0x1a9f, %edx           # imm = 0x1A9F
callq 0x24390
leaq 0x11d75(%rip), %rdi     # 0x7abd5
leaq 0x101f7(%rip), %rsi     # 0x7905e
leaq 0x12b2c(%rip), %rcx     # 0x7b99a
movl $0x1aa0, %edx           # imm = 0x1AA0
callq 0x24390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8(%rdi), %rbx
leaq -0x38(%rbp), %rsi
movb $0x2, (%rsi)
callq 0x690a8
leaq -0x58(%rbp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x6918c
cmpq $-0x1, %r15
je 0x68ec2
movq 0x10(%r14), %rax
movq -0x8(%rax), %rdi
callq 0x65488
cmpq %r15, %rax
jb 0x68ecf
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x242b0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x6561e
leaq 0x121bc(%rip), %rsi     # 0x7b0a9
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x675e8
movq 0x10(%r14), %rax
movq -0x8(%rax), %rcx
movb $0x1, %r15b
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x654b8
xorl %r15d, %r15d
leaq 0x44ae8(%rip), %rsi     # 0xada08
leaq -0x55ab(%rip), %rdx     # 0x6397c
movq %rbx, %rdi
callq 0x248f0
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x24ad8
jmp 0x68f43
movq %rax, %r14
movb $0x1, %r15b
leaq -0x38(%rbp), %rdi
callq 0x24ad8
testb %r15b, %r15b
jne 0x68f56
jmp 0x68f5e
movq %rax, %r14
movq %rbx, %rdi
callq 0x24430
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/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 0x68f89
movq -0x8(%rax), %rcx
cmpb $0x2, (%rcx)
jne 0x68fa8
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rbp
retq
leaq 0x11c97(%rip), %rdi     # 0x7ac27
leaq 0x100c7(%rip), %rsi     # 0x7905e
leaq 0x12a79(%rip), %rcx     # 0x7ba17
movl $0x1abf, %edx           # imm = 0x1ABF
callq 0x24390
leaq 0x12ae1(%rip), %rdi     # 0x7ba90
leaq 0x100a8(%rip), %rsi     # 0x7905e
leaq 0x12a5a(%rip), %rcx     # 0x7ba17
movl $0x1ac0, %edx           # imm = 0x1AC0
callq 0x24390
nop