LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/src/cbor/../utility.hxx
// Function: std::enable_if<!std::is_same<std::iterator_traits<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::iterator_category, std::input_iterator_tag>::value, std::pair<unsigned long, unsigned long>>::type test::imp::position_<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
inline auto position_(II b, II e)
                -> typename std::enable_if<!std::is_same<typename std::iterator_traits<II>::iterator_category, std::input_iterator_tag>::value, std::pair<std::size_t, std::size_t>>::type
            {
                std::size_t l = 1, c = 1;
                for ( ; b != e; ++b, ++c)
                    if (*b == '\n')
                        ++l, c = 0;
                return std::make_pair(l, c);
            }

// Assembly:
pushq $0x1
popq %rcx
movq %rcx, %rax
movq %rcx, %rdx
cmpq %rsi, %rdi
je 0xb01d
incq %rdx
xorl %r8d, %r8d
cmpb $0xa, (%rdi)
sete %r8b
cmoveq %rcx, %rdx
addq %r8, %rax
incq %rdi
jmp 0xafff
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/string.hxx
// Function: bool cxon::cio::str::imp::char_read_<cxon::JSON<cxon::cio::str::raw_traits<cxon::json::format_traits>>, cxon::cnt::range_container<char*>, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>, char>(cxon::cnt::range_container<char*>&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
inline bool char_read_(C& c, II& i, II e, Cx& cx) {
                II const o = i;
                    char32_t const c32 = chr::utf8_to_utf32<X>(i, e, cx);
                        if (c32 == chr::bad_utf32) return rewind(i, o), false;
                return char_append_(c, c32) || (rewind(i, o), cx/X::read_error::overflow);
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movq %r8, %rcx
callq 0xc21a
cmpl $-0x1, %eax
je 0xbfb1
movq %r14, %rdi
movl %eax, %esi
callq 0xbf0b
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xbfb3
pushq $0x8
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb670
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/char.hxx
// Function: std::enable_if<!is_random_access_iterator<std::istreambuf_iterator<char, std::char_traits<char>>>::value, char32_t>::type cxon::cio::chr::imp::u_to_<cxon::JSON<cxon::cio::str::raw_traits<cxon::json::format_traits>>>::dec<std::istreambuf_iterator<char, std::char_traits<char>>>(std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>)
static auto dec(II& i, II e) -> enable_if_t<!is_random_access_iterator<II>::value, char32_t> {
#                       define CXON_NEXT_HEX() if (++i == e || !is<X>::digit16(*i)) return bad_utf32
                            char32_t c;
                                CXON_NEXT_HEX(); c = hex_to_dec_[(unsigned char)*i];
                                CXON_NEXT_HEX(); c = hex_to_dec_[(unsigned char)*i] | (c << 4);
                                CXON_NEXT_HEX(); c = hex_to_dec_[(unsigned char)*i] | (c << 4);
                                CXON_NEXT_HEX(); c = hex_to_dec_[(unsigned char)*i] | (c << 4);
                            return ++i, c;
#                       undef CXON_NEXT_HEX
                    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movl %edx, 0x8(%r14)
callq 0x827e
movq %rax, %rdi
movq %r14, %rsi
callq 0x8294
pushq $-0x1
popq %rbp
testb %al, %al
jne 0xc1c7
movq %rbx, %rdi
callq 0x82c4
movzbl %al, %eax
leaq 0x301fa(%rip), %r15     # 0x3c2d0
testb $0x40, (%rax,%r15)
je 0xc1c7
movq %rbx, %rdi
callq 0x82c4
movzbl %al, %eax
leaq 0x2ff1d(%rip), %r14     # 0x3c010
movl (%r14,%rax,4), %r13d
movq %rbx, %rdi
callq 0x827e
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x8294
testb %al, %al
jne 0xc1c7
movq %rbx, %rdi
callq 0x82c4
movzbl %al, %eax
testb $0x40, (%rax,%r15)
je 0xc1c7
movq %rbx, %rdi
callq 0x82c4
movzbl %al, %eax
movl (%r14,%rax,4), %r12d
movq %rbx, %rdi
callq 0x827e
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x8294
testb %al, %al
jne 0xc1c7
movq %rbx, %rdi
callq 0x82c4
movzbl %al, %eax
testb $0x40, (%rax,%r15)
je 0xc1c7
movq %rbx, %rdi
callq 0x82c4
movzbl %al, %eax
shll $0x8, %r13d
shll $0x4, %r12d
orl %r13d, %r12d
orl (%r14,%rax,4), %r12d
movq %rbx, %rdi
callq 0x827e
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x8294
testb %al, %al
jne 0xc1c7
movq %rbx, %rdi
callq 0x82c4
movzbl %al, %eax
testb $0x40, (%rax,%r15)
je 0xc1c7
movq %rbx, %rdi
callq 0x82c4
movzbl %al, %eax
shll $0x4, %r12d
orl (%r14,%rax,4), %r12d
movq %rbx, %rdi
callq 0x827e
movl %r12d, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/value.hxx
// Function: bool cxon::cio::val::imp::value_<cxon::JSON<cxon::json::format_traits>>::skip<cxon::cio::val::sink<void> const, std::istreambuf_iterator<char, std::char_traits<char>>>(cxon::cio::val::sink<void> const&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>)
static bool skip(O& o, II& i, II e) {
                        if (*i == X::map::end)      return false;
                        CXON_IF_CONSTEXPR (X::list::end != X::map::end)
                            if (*i == X::list::end) return false;
                        if (*i == X::map::sep)      return false;
                        CXON_IF_CONSTEXPR (X::list::sep != X::map::sep)
                            if (*i == X::list::sep) return false;
                        if (*i == X::map::beg)      return skip_cnt_<X::map::beg, X::map::end>(o, i, e);
                        CXON_IF_CONSTEXPR (X::list::beg != X::map::beg)
                            if (*i == X::list::beg) return skip_cnt_<X::list::beg, X::list::end>(o, i, e);
                        if (*i == X::string::del)   return skip_str_(o, i, e);
                        else                        return skip_scl_(o, i, e);
                    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x82c4
cmpb $0x7d, %al
je 0xc815
movq %r15, %rdi
callq 0x82c4
cmpb $0x5d, %al
je 0xc815
movq %r15, %rdi
callq 0x82c4
cmpb $0x2c, %al
jne 0xc823
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x82c4
cmpb $0x7b, %al
jne 0xc84a
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc8a4
movq %r15, %rdi
callq 0x82c4
cmpb $0x5b, %al
jne 0xc871
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc956
movq %r15, %rdi
callq 0x82c4
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
cmpb $0x22, %al
jne 0xc898
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xca08
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xca2a
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/value.hxx
// Function: bool cxon::cio::val::imp::value_<cxon::JSON<cxon::json::format_traits>>::skip_cnt_<(char)123, (char)125, cxon::cio::val::sink<void> const, std::istreambuf_iterator<char, std::char_traits<char>>>(cxon::cio::val::sink<void> const&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>)
static bool skip_cnt_(O& o, II& i, II e) {
                            if (!poke(o, *i)) return false;
                            unsigned r = 0;
                            for (++i; i != e; ++i) {
                                switch (*i) {
                                    case CB:                CXON_POKE(o, *i);
                                                            ++r; break;
                                    case CE:                CXON_POKE(o, *i);
                                                            if (r == 0) return ++i, true;
                                                            --r; break;
                                    case X::string::del:    if (!skip_s_(o, i, e)) return false;
                                                            break;
                                    default:                CXON_POKE(o, *i);
                                }
                            }
                            return false;
                        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rdx, (%r15)
movl %ecx, 0x8(%r15)
movq %rsi, %rdi
callq 0x82c4
movq %rbx, %rdi
callq 0x827e
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8273
testb %al, %al
je 0xc93c
movq %rbx, %rdi
callq 0x82c4
cmpb $0x22, %al
je 0xc913
movzbl %al, %eax
movq %rbx, %rdi
cmpl $0x7d, %eax
je 0xc906
cmpl $0x7b, %eax
jne 0xc92d
callq 0x82c4
incl %ebp
jmp 0xc932
callq 0x82c4
testl %ebp, %ebp
je 0xc949
decl %ebp
jmp 0xc932
movq 0x8(%rsp), %rdx
movl 0x10(%rsp), %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xca92
testb %al, %al
jne 0xc932
jmp 0xc93c
callq 0x82c4
movq %rbx, %rdi
callq 0x827e
jmp 0xc8d2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x827e
movb $0x1, %al
jmp 0xc93e
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/value.hxx
// Function: bool cxon::cio::val::imp::value_<cxon::JSON<cxon::json::format_traits>>::skip_scl_<cxon::cio::val::sink<void> const, std::istreambuf_iterator<char, std::char_traits<char>>>(cxon::cio::val::sink<void> const&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>)
static bool skip_scl_(O& o, II& i, II e) {
                            for ( ; i != e; ++i) {
                                if (*i == X::map::end)      return true;
                                CXON_IF_CONSTEXPR (X::list::end != X::map::end)
                                    if (*i == X::list::end) return true;
                                if (*i == X::map::sep)      return true;
                                CXON_IF_CONSTEXPR (X::list::sep != X::map::sep)
                                    if (*i == X::list::sep) return true;
                                CXON_POKE(o, *i);
                            }
                            return false;
                        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rsp, %r14
movq %rdx, (%r14)
movl %ecx, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8273
movl %eax, %ebp
testb %al, %al
je 0xca86
movq %rbx, %rdi
callq 0x82c4
cmpb $0x7d, %al
je 0xca86
movq %rbx, %rdi
callq 0x82c4
cmpb $0x5d, %al
je 0xca86
movq %rbx, %rdi
callq 0x82c4
cmpb $0x2c, %al
je 0xca86
movq %rbx, %rdi
callq 0x82c4
movq %rbx, %rdi
callq 0x827e
jmp 0xca3f
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/value.hxx
// Function: bool cxon::cio::val::imp::value_<cxon::JSON<cxon::json::format_traits>>::skip_s_<cxon::cio::val::sink<void> const, std::istreambuf_iterator<char, std::char_traits<char>>>(cxon::cio::val::sink<void> const&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>)
static bool skip_s_(O& o, II& i, II e) {
                            if (!poke(o, *i)) return false;
                            for (++i; i != e; ++i) {
                                switch (*i)  {
                                    case '\\':              CXON_POKE(o, *i);
                                                            if (++i == e) return false;
                                                            CXON_POKE(o, *i); break;
                                    case X::string::del:    return poke(o, *i);
                                    default:                CXON_POKE(o, *i);
                                }
                            }
                            return false;
                        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rsp, %r14
movq %rdx, (%r14)
movl %ecx, 0x8(%r14)
movq %rsi, %rdi
callq 0x82c4
movq %rbx, %rdi
callq 0x827e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8273
testb %al, %al
je 0xcb05
movq %rbx, %rdi
callq 0x82c4
movl %eax, %ebp
movq %rbx, %rdi
callq 0x82c4
cmpb $0x5c, %bpl
je 0xcae9
movzbl %bpl, %eax
cmpl $0x22, %eax
jne 0xcaaf
jmp 0xcb09
movq %rbx, %rdi
callq 0x827e
movq %rax, %rdi
movq %r14, %rsi
callq 0x8294
testb %al, %al
jne 0xcb05
movq %rbx, %rdi
jmp 0xcaaa
xorl %eax, %eax
jmp 0xcb0b
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, bool, void>::value<std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(bool&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(bool& t, II& i, II e, Cx& cx) {
                    static_assert(*X::id::pos != *X::id::neg, "boolean literals ambiguous"); // for input-iterator, id must be consumed
                    if (!cio::consume<X>(i, e, cx))
                        return false;
                    II const o = i;
                        char const c = cio::peek(i, e);
                            if (c == *X::id::pos && cio::consume<X>(X::id::pos, i, e)) return t = true,  true;
                            if (c == *X::id::neg && cio::consume<X>(X::id::neg, i, e)) return t = false, true;
                    return cio::rewind(i, o), cx/json::read_error::boolean_invalid;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
callq 0xd5d7
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xbac3
cmpb $0x66, %al
je 0xd538
movzbl %al, %eax
cmpl $0x74, %eax
jne 0xd55f
leaq 0x2e775(%rip), %rdi     # 0x3bc96
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xd572
testb %al, %al
je 0xd55f
movb $0x1, (%r14)
jmp 0xd554
leaq 0x2e75c(%rip), %rdi     # 0x3bc9b
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xd572
testb %al, %al
je 0xd55f
movb $0x0, (%r14)
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x5
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb670
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>& cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::imbue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>()
T& imbue()
                noexcept(noexcept(value::construct<T>(std::declval<basic_node&>())))
            {
                if (!is<T>()) {
                    reset(), kind_ = node_kind_<basic_node, T>::value;
                    value::construct<T>(*this);
                }
                return value::get<T>(*this);
            }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, 0x20(%rdi)
je 0xd87b
movq %rbx, %rdi
callq 0xe8b8
movl $0x2, 0x20(%rbx)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lib/node.hxx
// Function: cxon::node::error_category::message[abi:cxx11](int) const
std::string message(int ev) const override {
            switch (static_cast<error>(ev)) {
                case error::ok:                         return "no error";
                case error::invalid:                    return "invalid input";
                case error::recursion_depth_exceeded:   return "recursion depth limit exceeded";
                default:                                return "unknown error";
            }
        }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x2, %edx
je 0xd9a8
cmpl $0x1, %edx
je 0xd99a
testl %edx, %edx
jne 0xd9b6
leaq 0x2e212(%rip), %rsi     # 0x3bba5
leaq 0xf(%rsp), %rdx
jmp 0xd9c2
leaq 0x2e30a(%rip), %rsi     # 0x3bcab
leaq 0xe(%rsp), %rdx
jmp 0xd9c2
leaq 0x2e30a(%rip), %rsi     # 0x3bcb9
leaq 0xd(%rsp), %rdx
jmp 0xd9c2
leaq 0x2e29c(%rip), %rsi     # 0x3bc59
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x40e0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::basic_node(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&)
basic_node(const basic_node& o)
                noexcept(value::is_nothrow_copy_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(std::allocator_traits<allocator_type>::select_on_container_copy_construction(o.alloc_))
            {
                switch (o.kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: value::copy_construct<T>(*this, o); break
                        CXON_JSON_TYPE_DEF(object);
                        CXON_JSON_TYPE_DEF(array);
                        CXON_JSON_TYPE_DEF(string);
                        CXON_JSON_TYPE_DEF(real);
                        CXON_JSON_TYPE_DEF(sint);
                        CXON_JSON_TYPE_DEF(uint);
                        CXON_JSON_TYPE_DEF(boolean);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
            }

// Assembly:
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
cmpq $0x7, %rax
ja 0xdf4e
leaq 0x2d2bb(%rip), %rcx     # 0x3b1f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rdi)
retq
jmp 0xe4cc
andq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
jmp 0xdfb2
jmp 0xe2be
movb (%rsi), %al
movb %al, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::basic_node(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&&)
basic_node(basic_node&& o)
                noexcept(value::is_nothrow_move_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(std::move(o.alloc_))
            {
                switch (o.kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: value::move_construct<T>(*this, std::move(o)); break
                        CXON_JSON_TYPE_DEF(object);
                        CXON_JSON_TYPE_DEF(array);
                        CXON_JSON_TYPE_DEF(string);
                        CXON_JSON_TYPE_DEF(real);
                        CXON_JSON_TYPE_DEF(sint);
                        CXON_JSON_TYPE_DEF(uint);
                        CXON_JSON_TYPE_DEF(boolean);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
            }

// Assembly:
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
cmpq $0x7, %rax
ja 0xdfa2
leaq 0x2d295(%rip), %rcx     # 0x3b210
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rdi)
movl $0x7, 0x20(%rsi)
retq
movq (%rsi), %rax
movq %rax, (%rdi)
retq
jmp 0xe4fa
andq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
movb (%rsi), %al
movb %al, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::operator<(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&)
bool operator <(const basic_node& f, const basic_node& s) noexcept {
                    if (f.kind_ != s.kind_)
                        return f.kind_ < s.kind_;
                    switch (f.kind_) {
#                       define CXON_JSON_TYPE_DEF(T)    case node_kind::T: return f.get<T>() < s.get<T>()
                            CXON_JSON_TYPE_DEF(object);
                            CXON_JSON_TYPE_DEF(array);
                            CXON_JSON_TYPE_DEF(string);
                            CXON_JSON_TYPE_DEF(real);
                            CXON_JSON_TYPE_DEF(sint);
                            CXON_JSON_TYPE_DEF(uint);
                            CXON_JSON_TYPE_DEF(boolean);
                            case node_kind::null: return false;
#                       undef CXON_JSON_TYPE_DEF
                    }
                    return false; // LCOV_EXCL_LINE
                }

// Assembly:
pushq %rax
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0xe55a
cmpl $0x6, %eax
ja 0xe572
movl %eax, %eax
leaq 0x2ccf2(%rip), %rcx     # 0x3b230
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0xe5b5
jmp 0xe55d
movq (%rdi), %rax
cmpq (%rsi), %rax
setl %al
popq %rcx
retq
popq %rax
jmp 0x70ac
movsd (%rsi), %xmm0
ucomisd (%rdi), %xmm0
seta %al
jmp 0xe55d
xorl %eax, %eax
jmp 0xe55d
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0xe59c
jmp 0xe55d
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0xe58f
movb (%rdi), %al
cmpb (%rsi), %al
setb %al
jmp 0xe55d
movq %rax, %rdi
callq 0x6ed7
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::basic_node(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&&, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>> const&)
basic_node(basic_node&& o, const allocator_type& al)
                noexcept(value::is_nothrow_move_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(al)
            {
                switch (o.kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: value::move_construct<T>(*this, std::move(o)); break
                        CXON_JSON_TYPE_DEF(object);
                        CXON_JSON_TYPE_DEF(array);
                        CXON_JSON_TYPE_DEF(string);
                        CXON_JSON_TYPE_DEF(real);
                        CXON_JSON_TYPE_DEF(sint);
                        CXON_JSON_TYPE_DEF(uint);
                        CXON_JSON_TYPE_DEF(boolean);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
            }

// Assembly:
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
cmpq $0x7, %rax
ja 0xe886
leaq 0x2c9ed(%rip), %rcx     # 0x3b24c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rdi)
movl $0x7, 0x20(%rsi)
retq
movq (%rsi), %rax
movq %rax, (%rdi)
retq
jmp 0xe4fa
andq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
movb (%rsi), %al
movb %al, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::reset()
void reset() noexcept {
                switch (kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: value::destruct<T>(*this); break
                        CXON_JSON_TYPE_DEF(object);
                        CXON_JSON_TYPE_DEF(array);
                        CXON_JSON_TYPE_DEF(string);
                        CXON_JSON_TYPE_DEF(real);
                        CXON_JSON_TYPE_DEF(sint);
                        CXON_JSON_TYPE_DEF(uint);
                        CXON_JSON_TYPE_DEF(boolean);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
                kind_ = node_kind::null;
            }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl $0x2, %eax
je 0xe8e1
cmpl $0x1, %eax
je 0xe8d7
testl %eax, %eax
jne 0xe8e9
movq %rbx, %rdi
callq 0xe8f2
jmp 0xe8e9
movq %rbx, %rdi
callq 0xe91c
jmp 0xe8e9
movq %rbx, %rdi
callq 0x4130
movl $0x7, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<is_dynamic_type<cxon::cbor::taggle<unsigned long long, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>>::value, void>::type cxon::value::controller<cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>::destruct<cxon::cbor::taggle<unsigned long long, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>>(cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>&)
static auto destruct(N& n) noexcept -> enable_if_t< is_dynamic_type<T>::value> {
                        using at = alc::rebind_t<allocator_type, T>;
                        at    al(n.alloc_);
                        std::allocator_traits<at>::destroy(al, get<T*>(n));
                        std::allocator_traits<at>::deallocate(al, get<T*>(n), 1);
                    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x8, %rdi
callq 0x1335c
movq (%rbx), %rdi
popq %rbx
jmp 0x4260
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<is_dynamic_type<std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>::value, void>::type cxon::value::controller<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>::construct<std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&)
static auto construct(N& n, A&&... t)
                        -> enable_if_t< is_dynamic_type<T>::value>
                    {
                        using at = alc::rebind_t<allocator_type, T>;
                        at    al(n.alloc_);
                        get<T*>(n) = std::allocator_traits<at>::allocate(al, 1);
                        alc::uninitialized_construct_using_allocator<T>(get<T*>(n), al, std::forward<A>(t)...);
                    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0xdff4
movq %rax, (%rbx)
leaq 0x8(%rax), %rcx
andl $0x0, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/numeric.hxx
// Function: std::enable_if<std::is_floating_point<double>::value, bool>::type cxon::cio::num::imp::number_read_<cxon::json::format_traits, double, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(double&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
inline auto number_read_(T& t, II& i, II e, Cx& cx)
                -> enable_if_t<std::is_floating_point<T>::value, bool>
            {
                II const o = i;
                    char s[num_len_max::constant<napa_type<Cx>>(64)];
                    switch (number_consume_<X, T>(std::begin(s), std::end(s), i, e)) {
                        case -1: return rewind(i, o), cx/X::read_error::overflow;
                        case  0: return rewind(i, o), cx/X::read_error::floating_point_invalid;
                        default: {
                            auto const r = from_chars_<X>(std::begin(s), std::end(s), t); CXON_ASSERT(r.ec == std::errc(), "unexpected");
                            return true;
                        }
                    }
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movl %ecx, %r8d
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x40(%rsp), %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0xf128
testl %eax, %eax
je 0xf101
cmpl $-0x1, %eax
jne 0xf10e
pushq $0x8
jmp 0xf103
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xb670
jmp 0xf11e
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf42f
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, std::nullptr_t, void>::value<std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(std::nullptr_t&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(std::nullptr_t& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<X>(i, e, cx))
                        return false;
                    II const o = i;
                    return  (cio::consume<X>(X::id::nil, i, e) && (t = nullptr, true)) ||
                            (cio::rewind(i, o), cx/json::read_error::unexpected)
                    ;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
callq 0xd5d7
leaq 0x2c6ec(%rip), %rdi     # 0x3bcf4
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xd572
testb %al, %al
je 0xf628
andq $0x0, (%r14)
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb670
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<test::kind::unquoted_keys_traits>, bool, void>::value<cxon::context<cxon::JSON<test::kind::unquoted_keys_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>, cxon::napa::imp::cst<cxon::node::json::extract_nans, bool, true>>>(bool&, char const*&, char const*, cxon::context<cxon::JSON<test::kind::unquoted_keys_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>, cxon::napa::imp::cst<cxon::node::json::extract_nans, bool, true>>&)
static bool value(bool& t, const char*& i, const char* e, Cx& cx) {
                    if (!cio::consume<X>(i, e, cx))
                        return false;
                    std::size_t const il = std::size_t(e - i);
                        constexpr auto pl = X::id::len::pos;
                    if (il >= pl && std::char_traits<char>::compare(X::id::pos, i, pl) == 0) return i += pl, t = true,  true;
                        constexpr auto nl = X::id::len::neg;
                    if (il >= nl && std::char_traits<char>::compare(X::id::neg, i, nl) == 0) return i += nl, t = false, true;
                    return cx/json::read_error::boolean_invalid;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1096d
movq (%r14), %r12
subq %r12, %r13
cmpq $0x4, %r13
jb 0x10ad6
cmpl $0x65757274, (%r12)     # imm = 0x65757274
je 0x10aea
cmpq $0x4, %r13
je 0x10ad6
leaq 0x2b1d4(%rip), %rdi     # 0x3bc9b
pushq $0x5
popq %rdx
movq %r12, %rsi
callq 0x4290
testl %eax, %eax
je 0x10af6
pushq $0x5
popq %rsi
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xfb7a
addq $0x4, %r12
movq %r12, (%r14)
movb $0x1, (%rbx)
jmp 0x10b00
addq $0x5, %r12
movq %r12, (%r14)
movb $0x0, (%rbx)
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<test::kind::unquoted_keys_traits>, std::nullptr_t, void>::value<cxon::context<cxon::JSON<test::kind::unquoted_keys_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>, cxon::napa::imp::cst<cxon::node::json::extract_nans, bool, true>>>(std::nullptr_t&, char const*&, char const*, cxon::context<cxon::JSON<test::kind::unquoted_keys_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>, cxon::napa::imp::cst<cxon::node::json::extract_nans, bool, true>>&)
static bool value(std::nullptr_t& t, const char*& i, const char* e, Cx& cx) {
                    if (!cio::consume<X>(i, e, cx))
                        return false;
                    constexpr auto nl = X::id::len::nil;
                    return  (std::size_t(e - i) >= nl && std::char_traits<char>::compare(X::id::nil, i, nl) == 0 && (i += nl, t = nullptr, true)) ||
                            cx/json::read_error::unexpected
                    ;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1096d
movq (%r15), %rax
subq %rax, %r12
cmpq $0x4, %r12
jb 0x10b3f
cmpl $0x6c6c756e, (%rax)     # imm = 0x6C6C756E
je 0x10b55
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfb7a
addq $0x4, %rax
movq %rax, (%r15)
andq $0x0, (%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<is_dynamic_type<std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>::value && !std::integral_constant<bool, false>::value, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&>::type cxon::value::controller<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>::copy_assign<std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&)
static auto copy_assign(N& n, const N& o)
                        -> enable_if_t< is_dynamic_type<T>::value && !propagate_on_container_copy_assignment::value, N&>
                    {
                        if (n.kind_ == o.kind_) {
                            get<T>(n).~T();
                            alc::uninitialized_construct_using_allocator<T>(&get<T>(n), n.alloc_, get<T>(o));
                        }
                        else {
                            n.reset(), n.kind_ = o.kind_;
                            construct<T>(n, get<T>(o));
                        }
                        return n;
                    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x10b99
movq (%rbx), %rdi
callq 0xe908
movq (%rbx), %rdi
leaq 0x24(%rbx), %rsi
movq (%r14), %rdx
callq 0x10bbe
jmp 0x10bb3
movq %rbx, %rdi
callq 0xe8b8
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xdfba
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<!is_dynamic_type<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::value && !std::integral_constant<bool, false>::value, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&>::type cxon::value::controller<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>::copy_assign<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&)
static auto copy_assign(N& n, const N& o) noexcept(std::is_nothrow_copy_constructible<T>::value)
                        -> enable_if_t<!is_dynamic_type<T>::value && !propagate_on_container_copy_assignment::value, N&>
                    {
                        if (n.kind_ == o.kind_) {
                            get<T>(n).~T();
                            alc::uninitialized_construct_using_allocator<T>(&get<T>(n), n.alloc_, get<T>(o));
                        }
                        else {
                            n.reset(), n.kind_ = o.kind_;
                            alc::uninitialized_construct_using_allocator<T>(&get<T>(n), n.alloc_, get<T>(o));
                        }
                        return n;
                    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x10c4c
movq %rbx, %rdi
callq 0x4130
jmp 0x10c5b
movq %rbx, %rdi
callq 0xe8b8
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
leaq 0x24(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe4d8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/error.hxx
// Function: cxon::cbor::read_error_category::message[abi:cxx11](int) const
std::string message(int ev) const override {
            switch (static_cast<read_error>(ev)) {
                case read_error::ok:                        return "no error";
                case read_error::unexpected:                return "unexpected input";
                case read_error::boolean_invalid:           return "invalid boolean";
                case read_error::null_invalid:              return "invalid null";
                case read_error::integer_invalid:           return "invalid integer";
                case read_error::floating_point_invalid:    return "invalid floating-point";
                case read_error::size_invalid:              return "invalid size";
                case read_error::array_invalid:             return "invalid array";
                case read_error::tag_invalid:               return "invalid tag";
                default:                                    return "unknown error";
            }
        }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x8, %edx
ja 0x1135b
movl %edx, %eax
leaq 0x2a008(%rip), %rcx     # 0x3b2dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2a8c1(%rip), %rsi     # 0x3bba5
leaq 0xf(%rsp), %rdx
jmp 0x11367
leaq 0x2aa07(%rip), %rsi     # 0x3bcf9
leaq 0xb(%rsp), %rdx
jmp 0x11367
leaq 0x2a90f(%rip), %rsi     # 0x3bc0f
leaq 0xd(%rsp), %rdx
jmp 0x11367
leaq 0x2a9de(%rip), %rsi     # 0x3bcec
leaq 0xc(%rsp), %rdx
jmp 0x11367
leaq 0x2aa11(%rip), %rsi     # 0x3bd2d
leaq 0x8(%rsp), %rdx
jmp 0x11367
leaq 0x2a884(%rip), %rsi     # 0x3bbae
leaq 0xe(%rsp), %rdx
jmp 0x11367
leaq 0x2a9d1(%rip), %rsi     # 0x3bd09
leaq 0xa(%rsp), %rdx
jmp 0x11367
leaq 0x2a9da(%rip), %rsi     # 0x3bd20
leaq 0x9(%rsp), %rdx
jmp 0x11367
leaq 0x2a9e7(%rip), %rsi     # 0x3bd3b
leaq 0x7(%rsp), %rdx
jmp 0x11367
leaq 0x2a8f7(%rip), %rsi     # 0x3bc59
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
callq 0x40e0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::cbor::imp::read_unsigned_<cxon::cbor::format_traits, char, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(char&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_unsigned_(T& t, II& i, II e, Cx& cx) {
                II const o = i;
                switch (auto const b = bio::get(i, e) & X::mnr) {
                    case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
                    case 0x08: case 0x09: case 0x0A: case 0x0B: case 0x0C: case 0x0D: case 0x0E: case 0x0F:
                    case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
                        return  (t = T(b), true);
                    case 0x18: case 0x19: case 0x1A: case 0x1B:
                        return  (bio::get(t, 1 << (b - 0x18), i, e)) ||
                                (bio::rewind(i, o), cx/cbor::read_error::integer_invalid)
                        ;
                    case 0x1C: case 0x1D: case 0x1E: case 0x1F:
                        return  (bio::rewind(i, o), cx/cbor::read_error::integer_invalid);
                    default:                                            // LCOV_EXCL_LINE
                        return  CXON_ASSERT(0, "unexpected"), false;    // LCOV_EXCL_LINE
                }
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq (%rsi), %r15
cmpq %rdx, %r15
je 0x1271a
leaq 0x1(%r15), %rcx
movq %rcx, (%r14)
movzbl (%r15), %ecx
andl $0x1f, %ecx
movq %rdx, %rax
movl $0xffffff, %edx         # imm = 0xFFFFFF
btl %ecx, %edx
jae 0x126f9
movb %cl, (%rdi)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movl $0xf000000, %edx        # imm = 0xF000000
btl %ecx, %edx
jae 0x1271a
addl $-0x18, %ecx
pushq $0x1
popq %rsi
shll %cl, %esi
movq %r14, %rdx
movq %rax, %rcx
callq 0x1273e
testb %al, %al
jne 0x126f1
movq %r15, (%r14)
pushq $0x4
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11218
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: std::enable_if<std::is_integral<char>::value, bool>::type cxon::bio::get<char, char const*>(char&, unsigned int, char const*&, char const*)
inline auto get(T& t, unsigned n, II& i, II e)
            -> enable_if_t<std::is_integral<T>::value, bool>
        {
            switch (n) {
                case 1:     return imp::get_<1>(t, i, e);
                case 2:     return imp::get_<2>(t, i, e);
                case 4:     return imp::get_<4>(t, i, e);
                case 8:     return imp::get_<8>(t, i, e);
                default:    return CXON_ASSERT(0, "unexpected"), false; // LCOV_EXCL_LINE
            }
        }

// Assembly:
xorl %eax, %eax
decl %esi
cmpl $0x7, %esi
ja 0x127a6
leaq 0x28c32(%rip), %r8      # 0x3b380
movslq (%r8,%rsi,4), %rsi
addq %r8, %rsi
jmpq *%rsi
movq (%rdx), %rax
cmpq %rcx, %rax
je 0x127a7
movb (%rax), %al
movb %al, (%rdi)
movq (%rdx), %rsi
incq %rsi
movb $0x1, %al
jmp 0x127a3
movq (%rdx), %rsi
subq %rsi, %rcx
cmpq $0x4, %rcx
jl 0x127a7
addq $0x4, %rsi
jmp 0x127a1
movq (%rdx), %rsi
subq %rsi, %rcx
cmpq $0x2, %rcx
jl 0x127a7
addq $0x2, %rsi
jmp 0x127a1
movq (%rdx), %rsi
subq %rsi, %rcx
cmpq $0x8, %rcx
jl 0x127a7
addq $0x8, %rsi
xorl %eax, %eax
movq %rsi, (%rdx)
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: std::enable_if<std::is_assignable<decltype(*std::begin(fp)), decltype(*fp0)>::value, bool>::type cxon::cbor::cnt::imp::read_array_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline auto read_array_(T& t, II& i, II e, Cx& cx)
                -> enable_if_t< std::is_assignable<decltype(*std::begin(t)), decltype(*i)>::value, bool>
            {
                auto const m = bio::peek(i, e);
                switch (m & X::mjr) {
                    case X::bstr: case X::tstr: return imp::read_array_b_<X>(t, m, i, e, cx);
                    case X::arr:                return imp::read_array_w_<X>(t, m, i, e, cx);
                    default:                    return cx/cbor::read_error::array_invalid;
                }
            }

// Assembly:
movq %rcx, %r8
movq %rdx, %rcx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x118bd
movq %rsi, %rdx
movzbl (%rax), %eax
movl %eax, %esi
andl $-0x20, %esi
cmpl $0x40, %esi
je 0x118b5
cmpl $0x80, %esi
je 0x118c8
cmpl $0x60, %esi
jne 0x118bd
movzbl %al, %esi
jmp 0x118d0
pushq $0x7
popq %rsi
movq %r8, %rdi
jmp 0x11218
movzbl %al, %esi
jmp 0x11907
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_b_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, unsigned char, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_array_b_(T& t, bio::byte m, II& i, II e, Cx& cx) {
                switch (m & X::mnr) {
                    case 0x1C: case 0x1D: case 0x1E:    return cx/cbor::read_error::size_invalid;
                    case 0x1F:                          return read_array_b_var_<X>(t, i, e, cx);
                    default:                            return read_array_b_fix_<X>(t, i, e, cx);
                }
            }

// Assembly:
andl $0x1f, %esi
leal -0x1c(%rsi), %eax
cmpl $0x3, %eax
jae 0x118e6
pushq $0x6
popq %rsi
movq %r8, %rdi
jmp 0x11218
cmpl $0x1f, %esi
jne 0x118f9
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
jmp 0x1193e
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
jmp 0x119ce