LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x50, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1163c0
movq %rax, %rcx
movb $0x1, %al
cmpq $0x2, %rcx
movb %al, -0x29(%rbp)
je 0x11622d
leaq -0x18(%rbp), %rdi
callq 0x1163c0
movq %rax, %rcx
movb $0x1, %al
cmpq $0x4, %rcx
movb %al, -0x29(%rbp)
je 0x11622d
leaq -0x18(%rbp), %rdi
callq 0x1163c0
cmpq $0x6, %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x116236
jmp 0x116238
jmp 0x116257
leaq 0x3016a(%rip), %rdi     # 0x1463a9
leaq 0x2e6a0(%rip), %rsi     # 0x1448e6
movl $0x1d64, %edx           # imm = 0x1D64
leaq 0x30196(%rip), %rcx     # 0x1463e8
callq 0x524b0
movq -0x38(%rbp), %rdi
movl 0x14(%rdi), %esi
callq 0x115ff0
leaq -0x18(%rbp), %rdi
callq 0x1163e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x116400
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x11630c
movq -0x38(%rbp), %rdi
callq 0x115c20
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rax
movl (%rax), %ecx
xorl %eax, %eax
cmpl 0x14(%rdx), %ecx
movb %al, -0x41(%rbp)
jg 0x1162c9
movq -0x38(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
cmpl 0x4(%rcx), %eax
setle %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1162d6
jmp 0x1162e4
movq -0x38(%rbp), %rdi
movl 0x14(%rdi), %esi
callq 0x115ff0
jmp 0x1162f9
movq -0x38(%rbp), %rax
leaq 0x2ff69(%rip), %rcx     # 0x146258
movq %rcx, 0x70(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x116310
jmp 0x1162fb
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x116270
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x78(%rax)
testb $0x1, 0xa0(%rax)
je 0x117eba
movl $0x28, %edi
callq 0x52380
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
movq -0x20(%rbp), %rsi
callq 0x128a20
movq -0x28(%rbp), %rdi
leaq 0xa8c0a(%rip), %rsi     # 0x1c0ab8
leaq 0x6db(%rip), %rdx       # 0x118590
callq 0x52c20
xorl %eax, %eax
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x52a00
movq -0x58(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd1aa0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd1ad0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd2000
testb $0x1, %al
jne 0x117f8b
jmp 0x118032
leaq -0x28(%rbp), %rdi
callq 0xd2040
movb (%rax), %al
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x1f, %eax
jg 0x118011
movb $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x128aa0
movq -0x70(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x128ac0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movzbl -0x31(%rbp), %ecx
leaq 0x2fc69(%rip), %rdx     # 0x147c43
xorl %eax, %eax
callq 0x52b30
movq -0x70(%rbp), %rdi
callq 0x128aa0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x526e0
jmp 0x117ff8
jmp 0x118022
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x52e58
jmp 0x118052
movq -0x68(%rbp), %rdi
movsbl -0x31(%rbp), %esi
callq 0x52630
jmp 0x118020
jmp 0x118022
jmp 0x118024
leaq -0x28(%rbp), %rdi
callq 0xd2130
jmp 0x117f75
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x118045
movq -0x68(%rbp), %rdi
callq 0x52e58
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %esi
callq 0x111360
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x129660
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x129690
movq -0x18(%rbp), %rdi
callq 0x11dcc0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x111360
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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>::max_size() const
size_type max_size() const noexcept
    {
        switch (m_type)
        {
            case value_t::array:
            {
                // delegate call to array_t::max_size()
                return m_value.array->max_size();
            }

            case value_t::object:
            {
                // delegate call to object_t::max_size()
                return m_value.object->max_size();
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                // all other types have max_size() == size()
                return size();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x11d65d
movq -0x18(%rbp), %rax
leaq 0x26dc0(%rip), %rcx     # 0x1443ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11e120
movq %rax, -0x8(%rbp)
jmp 0x11d66a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11ec20
movq %rax, -0x8(%rbp)
jmp 0x11d66a
jmp 0x11d65d
movq -0x20(%rbp), %rdi
callq 0x11ec40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x111360
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
callq 0x11dcc0
jmp 0x11da7d
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x111360
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8c060
nopl (%rax)
// File: xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::iter_impl<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++()
iter_impl& operator++()
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
            {
                std::advance(m_it.object_iterator, 1);
                break;
            }

            case value_t::array:
            {
                std::advance(m_it.array_iterator, 1);
                break;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                ++m_it.primitive_iterator;
                break;
            }
        }

        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x11fb1c
jmp 0x11fb3b
leaq 0x27766(%rip), %rdi     # 0x147289
leaq 0x24dbc(%rip), %rsi     # 0x1448e6
movl $0x3371, %edx           # imm = 0x3371
leaq 0x27b2b(%rip), %rcx     # 0x147661
callq 0x524b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x11fb91
movq -0x18(%rbp), %rax
leaq 0x2495a(%rip), %rcx     # 0x1444b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x124570
jmp 0x11fba2
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x1245c0
jmp 0x11fba2
jmp 0x11fb91
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x124610
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::iter_impl<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>>::iter_impl(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>*)
explicit iter_impl(pointer object) noexcept : m_object(object)
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
            {
                m_it.object_iterator = typename object_t::iterator();
                break;
            }

            case value_t::array:
            {
                m_it.array_iterator = typename array_t::iterator();
                break;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                m_it.primitive_iterator = primitive_iterator_t();
                break;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x523d0
movq -0x38(%rbp), %rdi
callq 0x1231f0
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x123068
jmp 0x123087
leaq 0x2421a(%rip), %rdi     # 0x147289
leaq 0x21870(%rip), %rsi     # 0x1448e6
movl $0x325c, %edx           # imm = 0x325C
leaq 0x2421b(%rip), %rcx     # 0x14729d
callq 0x524b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq %rax, -0x40(%rbp)
subq $0x9, %rax
ja 0x1230df
movq -0x40(%rbp), %rax
leaq 0x21436(%rip), %rcx     # 0x1444dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x18(%rbp), %rdi
callq 0x123240
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x123104
leaq -0x20(%rbp), %rdi
callq 0x123260
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x123104
jmp 0x1230df
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x523d0
leaq -0x28(%rbp), %rdi
callq 0x123280
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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>::type_name() const
JSON_HEDLEY_RETURNS_NON_NULL
    const char* type_name() const noexcept
    {
        switch (m_type)
        {
            case value_t::null:
                return "null";
            case value_t::object:
                return "object";
            case value_t::array:
                return "array";
            case value_t::string:
                return "string";
            case value_t::boolean:
                return "boolean";
            case value_t::binary:
                return "binary";
            case value_t::discarded:
                return "discarded";
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            default:
                return "number";
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x123e2a
movq -0x18(%rbp), %rax
leaq 0x207b8(%rip), %rcx     # 0x14457c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x208a4(%rip), %rax     # 0x144678
movq %rax, -0x8(%rbp)
jmp 0x123e35
leaq 0x22ab9(%rip), %rax     # 0x14689a
movq %rax, -0x8(%rbp)
jmp 0x123e35
leaq 0x2652a(%rip), %rax     # 0x14a318
movq %rax, -0x8(%rbp)
jmp 0x123e35
leaq 0x208c9(%rip), %rax     # 0x1446c4
movq %rax, -0x8(%rbp)
jmp 0x123e35
leaq 0x23840(%rip), %rax     # 0x147648
movq %rax, -0x8(%rbp)
jmp 0x123e35
leaq 0x2383b(%rip), %rax     # 0x147650
movq %rax, -0x8(%rbp)
jmp 0x123e35
leaq 0x23835(%rip), %rax     # 0x147657
movq %rax, -0x8(%rbp)
jmp 0x123e35
jmp 0x123e2a
leaq 0x1ae47(%rip), %rax     # 0x13ec78
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
callq 0x1249b0
movq -0x8(%rbp), %rax
movb $0x3, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x11fc30
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x111360
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzbl (%rax), %esi
callq 0x1249b0
jmp 0x126bb6
movq -0x8(%rbp), %rax
movb $0x7, (%rax)
movsd -0x10(%rbp), %xmm0
leaq -0x18(%rbp), %rdi
callq 0x11fcd0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x111360
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8c060
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzbl (%rax), %esi
callq 0x1249b0
jmp 0x127229
movq -0x8(%rbp), %rax
movb $0x4, (%rax)
movb -0x9(%rbp), %al
leaq -0x18(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x11fc70
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x111360
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8c060
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzbl (%rax), %esi
callq 0x1249b0
jmp 0x127da5
movq -0x8(%rbp), %rax
movb $0x5, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x11fc90
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x111360
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8c060
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzbl (%rax), %esi
callq 0x1249b0
jmp 0x128925
movq -0x8(%rbp), %rax
movb $0x6, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x11fcb0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x111360
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8c060
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x78(%rbp)
movb $0x1, -0x19(%rbp)
leaq -0x19(%rbp), %rsi
callq 0x129db0
movq -0x78(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x129d80
xorl %eax, %eax
cmpq $-0x1, -0x10(%rbp)
movb %al, -0x6e(%rbp)
je 0x129753
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x8, %rdi
callq 0x11d5c0
movq (%rax), %rdi
callq 0x11d600
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
seta %al
movb %al, -0x6e(%rbp)
movb -0x6e(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x129763
jmp 0x129834
movb $0x1, -0x6d(%rbp)
movl $0x20, %edi
callq 0x52380
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x11d8d0
jmp 0x129787
leaq 0x1d113(%rip), %rsi     # 0x1468a1
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x11d830
jmp 0x12979d
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x11d5c0
movq -0x90(%rbp), %rdi
movq (%rax), %rcx
movl $0x198, %esi            # imm = 0x198
leaq -0x40(%rbp), %rdx
callq 0x11d680
jmp 0x1297c4
movq -0x90(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0x97222(%rip), %rsi     # 0x1c09f8
leaq -0xcadd(%rip), %rdx     # 0x11cd00
callq 0x52c20
jmp 0x12984a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12981e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x129815
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x52e58
leaq -0x60(%rbp), %rdi
callq 0x52e58
testb $0x1, -0x6d(%rbp)
jne 0x129826
jmp 0x129832
movq -0x90(%rbp), %rdi
callq 0x52540
jmp 0x129841
movb $0x1, %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x52c90
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x11d9e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x129875
jmp 0x129877
jmp 0x129896
leaq 0x1d199(%rip), %rdi     # 0x146a17
leaq 0x1b061(%rip), %rsi     # 0x1448e6
movl $0x1aa9, %edx           # imm = 0x1AA9
leaq 0x1e6cc(%rip), %rcx     # 0x147f5d
callq 0x524b0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x11d5c0
movq (%rax), %rdi
callq 0x11daf0
testb $0x1, %al
jne 0x1298b1
jmp 0x1298b3
jmp 0x1298d2
leaq 0x1d10b(%rip), %rdi     # 0x1469c5
leaq 0x1b025(%rip), %rsi     # 0x1448e6
movl $0x1aaa, %edx           # imm = 0x1AAA
leaq 0x1e690(%rip), %rcx     # 0x147f5d
callq 0x524b0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x11d5c0
movq (%rax), %rdi
callq 0x11dcc0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x11f250
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x11d9e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x129929
jmp 0x12992b
jmp 0x12994a
leaq 0x1d0e5(%rip), %rdi     # 0x146a17
leaq 0x1afad(%rip), %rsi     # 0x1448e6
movl $0x1a9f, %edx           # imm = 0x1A9F
leaq 0x1e692(%rip), %rcx     # 0x147fd7
callq 0x524b0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x11d5c0
movq (%rax), %rdi
callq 0x11daf0
testb $0x1, %al
jne 0x129965
jmp 0x129967
jmp 0x129986
leaq 0x1d057(%rip), %rdi     # 0x1469c5
leaq 0x1af71(%rip), %rsi     # 0x1448e6
movl $0x1aa0, %edx           # imm = 0x1AA0
leaq 0x1e656(%rip), %rcx     # 0x147fd7
callq 0x524b0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x11d5c0
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1247e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x78(%rbp)
movb $0x2, -0x19(%rbp)
leaq -0x19(%rbp), %rsi
callq 0x129db0
movq -0x78(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x129d80
xorl %eax, %eax
cmpq $-0x1, -0x10(%rbp)
movb %al, -0x6e(%rbp)
je 0x129a43
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x8, %rdi
callq 0x11d5c0
movq (%rax), %rdi
callq 0x11d600
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
seta %al
movb %al, -0x6e(%rbp)
movb -0x6e(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x129a53
jmp 0x129b24
movb $0x1, -0x6d(%rbp)
movl $0x20, %edi
callq 0x52380
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x11d8d0
jmp 0x129a77
leaq 0x1dc68(%rip), %rsi     # 0x1476e6
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x126290
jmp 0x129a8d
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x11d5c0
movq -0x90(%rbp), %rdi
movq (%rax), %rcx
movl $0x198, %esi            # imm = 0x198
leaq -0x40(%rbp), %rdx
callq 0x11d680
jmp 0x129ab4
movq -0x90(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0x96f32(%rip), %rsi     # 0x1c09f8
leaq -0xcdcd(%rip), %rdx     # 0x11cd00
callq 0x52c20
jmp 0x129b3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x129b0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x129b05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x52e58
leaq -0x60(%rbp), %rdi
callq 0x52e58
testb $0x1, -0x6d(%rbp)
jne 0x129b16
jmp 0x129b22
movq -0x90(%rbp), %rdi
callq 0x52540
jmp 0x129b31
movb $0x1, %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x52c90
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x11d9e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x129b65
jmp 0x129b67
jmp 0x129b86
leaq 0x1cea9(%rip), %rdi     # 0x146a17
leaq 0x1ad71(%rip), %rsi     # 0x1448e6
movl $0x1abf, %edx           # imm = 0x1ABF
leaq 0x1e4d3(%rip), %rcx     # 0x148054
callq 0x524b0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x11d5c0
movq (%rax), %rdi
callq 0x11dad0
testb $0x1, %al
jne 0x129ba1
jmp 0x129ba3
jmp 0x129bc2
leaq 0x1e523(%rip), %rdi     # 0x1480cd
leaq 0x1ad35(%rip), %rsi     # 0x1448e6
movl $0x1ac0, %edx           # imm = 0x1AC0
leaq 0x1e497(%rip), %rcx     # 0x148054
callq 0x524b0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x11d5c0
movq (%rax), %rdi
callq 0x11dcc0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x11f250
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::BinaryExpr<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>> const&>::BinaryExpr(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::StringRef, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
        :   ITransientExpression{ true, comparisonResult },
            m_lhs( lhs ),
            m_op( op ),
            m_rhs( rhs )
        {}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %rdx, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movb -0x19(%rbp), %al
movl $0x1, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xb7670
movq -0x38(%rbp), %rax
leaq 0x94aff(%rip), %rcx     # 0x1c0b38
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/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>, char [39], 0>(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>&, char const (&) [39])
static void construct(BasicJsonType& j, const CompatibleStringType& str)
    {
        j.m_value.destroy(j.m_type);
        j.m_type = value_t::string;
        j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
callq 0x1249b0
movq -0x8(%rbp), %rax
movb $0x3, (%rax)
movq -0x10(%rbp), %rdi
callq 0x131a90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x111360
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x132280
testb $0x1, %al
jne 0x13213a
jmp 0x132158
movq -0x78(%rbp), %rax
movb $0x1, (%rax)
callq 0x111660
movq -0x78(%rbp), %rdi
movq %rax, 0x8(%rdi)
movl $0x1, %esi
callq 0x111360
movq -0x78(%rbp), %rdi
callq 0x11daf0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13216b
jmp 0x1321c6
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rsi
movq 0x8(%rax), %rdi
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x1322a0
movb %dl, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movb -0x30(%rbp), %al
movb %al, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x123970
movq -0x78(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
movq $-0x1, %rdx
callq 0x1322f0
addq $0x90, %rsp
popq %rbp
retq
movb $0x1, -0x6d(%rbp)
movl $0x20, %edi
callq 0x52380
movq -0x78(%rbp), %rdi
movq %rax, -0x88(%rbp)
callq 0x123da0
movq %rax, -0x60(%rbp)
leaq 0x170d9(%rip), %rsi     # 0x1492c8
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x132310
jmp 0x1321fe
movq -0x78(%rbp), %rcx
movq -0x88(%rbp), %rdi
movl $0x131, %esi            # imm = 0x131
leaq -0x58(%rbp), %rdx
callq 0x123b50
jmp 0x132219
movq -0x88(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0x8e84d(%rip), %rsi     # 0x1c0a78
leaq -0xe3f2(%rip), %rdx     # 0x123e40
callq 0x52c20
jmp 0x13227b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x13225c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x52e58
testb $0x1, -0x6d(%rbp)
jne 0x132264
jmp 0x132270
movq -0x88(%rbp), %rdi
callq 0x52540
jmp 0x132272
movq -0x68(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)