LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/json/lib/std/imp/map.hxx
// Function: bool cxon::json::imp::map_element_reader_<cxon::JSON<cxon::cxcf::format_traits>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, test::fix, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, test::fix>>>>::read<char const*, cxon::context<cxon::JSON<cxon::cxcf::format_traits>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, test::fix, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, test::fix>>>&, char const*&, char const*, cxon::context<cxon::JSON<cxon::cxcf::format_traits>>&)
static bool read(M& t, II& i, II e, Cx& cx) {
                    typename M::key_type    k = alc::create_using_allocator_of<typename M::key_type>(t);
                    typename M::mapped_type v = alc::create_using_allocator_of<typename M::mapped_type>(t);
                    return  cio::read_map_key<X>(k, i, e, cx) &&
                            cio::read_map_val<X>(cnt::emplace(t, std::move(k), std::move(v)).second, i, e, cx)
                    ;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
leaq 0x8(%rsp), %rdi
movq %rbx, %rcx
callq 0xaa7a
testb %al, %al
je 0xcbb0
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0xd276
movq %rax, %r12
leaq 0x37df4(%rip), %rax     # 0x44945
leaq 0xa0(%rsp), %rdi
movq %rax, (%rdi)
movl $0x4, %eax
movq %rax, 0x8(%rdi)
movq $0x20, 0x10(%rdi)
leaq 0x37dcc(%rip), %rcx     # 0x44940
leaq 0x88(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
movq $0x40, 0x10(%rsi)
callq 0xcc35
addq $0x20, %r12
leaq 0x4b8bd(%rip), %rsi     # 0x58458
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0xcca0
movl %eax, %ebx
jmp 0xcbb2
xorl %ebx, %ebx
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0xcbc1
callq 0x4220
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0xcbd0
callq 0x4220
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xcbe4
callq 0x4220
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xcbf8
callq 0x4220
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8bd0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xcc2d
callq 0x4220
movq %rbx, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/char.hxx
// Function: std::enable_if<is_random_access_iterator<char const*>::value, char32_t>::type cxon::cio::chr::imp::u_to_<cxon::JSON<cxon::cio::key::quoted_traits<cxon::cxcf::format_traits>>>::dec<char const*>(char const*&, char const*)
static auto dec(II& i, II e) -> enable_if_t< is_random_access_iterator<II>::value, char32_t> {
                        if (e - i < 5 || !is<X>::digit16(i[1]) || !is<X>::digit16(i[2]) || !is<X>::digit16(i[3]) || !is<X>::digit16(i[4]))
                            return bad_utf32;
                        char32_t const c =  (hex_to_dec_[(unsigned char)i[1]] << 12) |
                                            (hex_to_dec_[(unsigned char)i[2]] <<  8) |
                                            (hex_to_dec_[(unsigned char)i[3]] <<  4) |
                                            (hex_to_dec_[(unsigned char)i[4]] <<  0)
                        ;
                        return i += 5, c;
                    }

// Assembly:
movq (%rdi), %rcx
subq %rcx, %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x5, %rsi
jl 0xb2ab
movzbl 0x1(%rcx), %edx
leaq 0x39e2a(%rip), %r10     # 0x45080
testb $0x40, (%rdx,%r10)
je 0xb2ab
movzbl 0x2(%rcx), %r8d
testb $0x40, (%r8,%r10)
je 0xb2ab
movzbl 0x3(%rcx), %r9d
testb $0x40, (%r9,%r10)
je 0xb2ab
movzbl 0x4(%rcx), %esi
testb $0x40, (%rsi,%r10)
je 0xb2ab
leaq 0x39b39(%rip), %r10     # 0x44dc0
movl (%r10,%rdx,4), %eax
shll $0xc, %eax
movl (%r10,%r8,4), %edx
shll $0x8, %edx
orl %eax, %edx
movl (%r10,%r9,4), %eax
shll $0x4, %eax
orl %edx, %eax
orl (%r10,%rsi,4), %eax
addq $0x5, %rcx
movq %rcx, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/json/error.hxx
// Function: cxon::json::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::character_invalid:         return "invalid character";
                case read_error::integral_invalid:          return "invalid integral or value out of range";
                case read_error::floating_point_invalid:    return "invalid floating point";
                case read_error::boolean_invalid:           return "invalid boolean";
                case read_error::escape_invalid:            return "invalid escape sequence";
                case read_error::surrogate_invalid:         return "invalid surrogate";
                case read_error::overflow:                  return "buffer overflow";
                default:                                    return "unknown error";
            }
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x8, %edx
ja 0xe00f
movl %edx, %eax
leaq 0x36279(%rip), %rcx     # 0x441ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x369da(%rip), %rsi     # 0x4495d
leaq 0x369db(%rip), %rdx     # 0x44965
jmp 0xe01d
leaq 0x36a1a(%rip), %rsi     # 0x449b0
leaq 0x36a29(%rip), %rdx     # 0x449c6
jmp 0xe01d
leaq 0x369d1(%rip), %rsi     # 0x44977
leaq 0x369db(%rip), %rdx     # 0x44988
jmp 0xe01d
leaq 0x369d3(%rip), %rsi     # 0x44989
leaq 0x369f2(%rip), %rdx     # 0x449af
jmp 0xe01d
leaq 0x36a29(%rip), %rsi     # 0x449ef
leaq 0x36a33(%rip), %rdx     # 0x44a00
jmp 0xe01d
leaq 0x36990(%rip), %rsi     # 0x44966
leaq 0x36999(%rip), %rdx     # 0x44976
jmp 0xe01d
leaq 0x369e1(%rip), %rsi     # 0x449c7
leaq 0x369e9(%rip), %rdx     # 0x449d6
jmp 0xe01d
leaq 0x369e1(%rip), %rsi     # 0x449d7
leaq 0x369f1(%rip), %rdx     # 0x449ee
jmp 0xe01d
leaq 0x369fb(%rip), %rsi     # 0x44a01
leaq 0x36a03(%rip), %rdx     # 0x44a10
jmp 0xe01d
leaq 0x369fb(%rip), %rsi     # 0x44a11
leaq 0x36a01(%rip), %rdx     # 0x44a1e
movq %rbx, %rdi
callq 0x98ac
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9cb2
cmpb $0x7d, %al
je 0x10969
movq %r15, %rdi
callq 0x9cb2
cmpb $0x5d, %al
je 0x10969
movq %r15, %rdi
callq 0x9cb2
cmpb $0x2c, %al
jne 0x10977
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x9cb2
cmpb $0x7b, %al
jne 0x1099e
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x109f8
movq %r15, %rdi
callq 0x9cb2
cmpb $0x5b, %al
jne 0x109c5
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10b62
movq %r15, %rdi
callq 0x9cb2
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
cmpb $0x22, %al
jne 0x109ec
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10ccc
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10d0a
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
cmpl $-0x1, %ebx
sete %r12b
movq %r14, %rdi
callq 0x9cb2
movl %eax, %ebp
testq %r15, %r15
setne %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x10d49
movq 0x10(%r15), %rax
cmpq 0x18(%r15), %rax
jae 0x10db1
cmpl $-0x1, %ebp
je 0x10d59
jmp 0x10dc7
cmpl $-0x1, %ebp
sete %al
cmpl $-0x1, %ebx
sete %cl
cmpb %al, %cl
je 0x10dc7
movq %r14, %rdi
callq 0x9cb2
movb $0x1, %r12b
cmpb $0x7d, %al
je 0x10dca
movq %r14, %rdi
callq 0x9cb2
cmpb $0x5d, %al
je 0x10dca
movq %r14, %rdi
callq 0x9cb2
cmpb $0x2c, %al
je 0x10dca
movq %r14, %rdi
callq 0x9cb2
movq (%r14), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x10da9
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
jmp 0x10d1a
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x10d9c
movq (%r15), %rax
movq %r15, %rdi
callq *0x48(%rax)
cmpl $-0x1, %eax
jne 0x10d42
xorl %r15d, %r15d
cmpl $-0x1, %ebp
jne 0x10d59
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x9cb2
movq (%r14), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x10e82
incq %rax
movq %rax, 0x10(%rdi)
cmpl $-0x1, %ebp
sete %r12b
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x9cb2
movl %eax, %r15d
testq %rbx, %rbx
setne %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x10e42
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x10e8d
cmpl $-0x1, %r15d
je 0x10e57
jmp 0x10f2e
cmpl $-0x1, %r15d
sete %al
cmpl $-0x1, %ebp
sete %cl
cmpb %al, %cl
je 0x10f2e
movq %r14, %rdi
callq 0x9cb2
movl %eax, %r15d
movq %r14, %rdi
callq 0x9cb2
cmpb $0x5c, %r15b
je 0x10ea8
movzbl %r15b, %eax
cmpl $0x22, %eax
jne 0x10dee
jmp 0x10f32
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x10e06
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
cmpl $-0x1, %eax
jne 0x10e37
xorl %ebx, %ebx
cmpl $-0x1, %r15d
jne 0x10e57
jmp 0x10f34
movq (%r14), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x10f0e
incq %rax
movq %rax, 0x10(%rdi)
cmpl $-0x1, %ebp
sete %r12b
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x9cb2
movl %eax, %r15d
testq %rbx, %rbx
setne %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x10ef5
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x10f16
cmpl $-0x1, %r15d
je 0x10f06
jmp 0x10f2e
cmpl $-0x1, %r15d
sete %al
cmpl $-0x1, %ebp
setne %cl
xorb %al, %cl
jne 0x10f2e
movq %r14, %rdi
jmp 0x10de9
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x10ebc
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
cmpl $-0x1, %eax
jne 0x10eed
xorl %ebx, %ebx
cmpl $-0x1, %r15d
jne 0x10f06
jmp 0x10f34
xorl %ebx, %ebx
jmp 0x10f34
movb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: 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>>>::imbue<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>>>>>>>()
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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
je 0x12c5b
movq %rbx, %rdi
callq 0x13dae
xorl %r14d, %r14d
movl %r14d, 0x20(%rbx)
movl $0x30, %edi
callq 0x4230
movq %rax, (%rbx)
leaq 0x8(%rax), %rcx
movl %r14d, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %r14, 0x28(%rax)
jmp 0x12c5e
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x2, %edx
je 0x12d13
cmpl $0x1, %edx
je 0x12d03
testl %edx, %edx
jne 0x12d23
leaq 0x31c63(%rip), %rsi     # 0x4495d
leaq 0x31c64(%rip), %rdx     # 0x44965
jmp 0x12d31
leaq 0x31d59(%rip), %rsi     # 0x44a63
leaq 0x31d5f(%rip), %rdx     # 0x44a70
jmp 0x12d31
leaq 0x31d57(%rip), %rsi     # 0x44a71
leaq 0x31d6e(%rip), %rdx     # 0x44a8f
jmp 0x12d31
leaq 0x31ce7(%rip), %rsi     # 0x44a11
leaq 0x31ced(%rip), %rdx     # 0x44a1e
movq %rbx, %rdi
callq 0x98ac
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lib/node.json.hxx
// Function: std::enable_if<cxon::JSON<cxon::json::format_traits>::quote_unquoted_keys, bool>::type cxon::cio::key::read<cxon::JSON<cxon::json::format_traits>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>::key<std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(cxon::json::basic_node<cxon::json::node_traits<std::allocator<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>>&)
static auto key(json::basic_node<Tr>& t, II& i, II e, Cx& cx)
                        -> enable_if_t< Y::quote_unquoted_keys, bool>
                    {
#                       define CXON_IMBUE(T) t.template imbue<typename json::basic_node<Tr>::T>()
                            CXON_IF_CONSTEXPR (Y::unquote_quoted_keys) {
                                if (!cio::consume<Y>(i, e, cx))
                                    return false;
                                switch (cio::peek(i, e)) {
                                    case '{': { CXON_NODE_RG(); return read_key_(t, CXON_IMBUE(object), i, e, cx); }
                                    case '[': { CXON_NODE_RG(); return read_key_(t, CXON_IMBUE(array),  i, e, cx); }
                                }
                            }
                            return cio::key::read_key<Y>(CXON_IMBUE(string), i, e, cx);
#                       undef CXON_IMBUE
                    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpl $0x2, 0x20(%rdi)
je 0x13167
movq %r12, %rdi
callq 0x13dae
movl $0x2, 0x20(%r12)
leaq 0x10(%r12), %rax
movq %rax, (%r12)
movq $0x0, 0x8(%r12)
movb $0x0, 0x10(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10fd6
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
cmpq $0x7, %rax
ja 0x134bd
movq %rdi, %rbx
leaq 0x30e22(%rip), %rcx     # 0x44250
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rbx)
jmp 0x134bd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13922
movq $0x0, (%rbx)
jmp 0x134bd
movsd (%rsi), %xmm0
movsd %xmm0, (%rbx)
jmp 0x134bd
movq (%rsi), %r14
movl $0x30, %edi
callq 0x4230
movq %rax, (%rbx)
leaq 0x6(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x13556
jmp 0x134bd
movq (%rsi), %r14
movl $0x18, %edi
callq 0x4230
movq %rax, (%rbx)
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x137e4
jmp 0x134bd
movb (%rsi), %al
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13529
leaq 0x30d97(%rip), %rcx     # 0x44270
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
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq (%rsi), %rdx
leaq 0x10(%rsi), %rax
cmpq %rax, %rdx
je 0x13538
movq %rdx, (%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rdi)
movq %rax, (%rsi)
jmp 0x13549
movq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
movb (%rsi), %al
movb %al, (%rdi)
retq
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq (%rsi), %rax
movq $0x0, 0x8(%rsi)
movb $0x0, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x139e1
cmpl $0x6, %eax
ja 0x139fd
movl %eax, %eax
leaq 0x308de(%rip), %rcx     # 0x44290
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
movq (%rsi), %rcx
movq 0x18(%rax), %rdi
addq $0x8, %rax
movq 0x18(%rcx), %rdx
addq $0x8, %rcx
movq %rax, %rsi
callq 0x13a37
jmp 0x139e4
movq (%rdi), %rax
cmpq (%rsi), %rax
setl %al
popq %rcx
retq
callq 0x4030
shrl $0x1f, %eax
jmp 0x139e4
movsd (%rsi), %xmm0
ucomisd (%rdi), %xmm0
seta %al
jmp 0x139e4
xorl %eax, %eax
jmp 0x139e4
movq (%rdi), %rax
movq (%rsi), %rcx
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
callq 0x13b32
jmp 0x139e4
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x13a28
movb (%rdi), %al
cmpb (%rsi), %al
setb %al
jmp 0x139e4
jmp 0x13a2f
movq %rax, %rdi
callq 0x8504
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13d81
leaq 0x3059b(%rip), %rcx     # 0x442cc
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
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq (%rsi), %rdx
leaq 0x10(%rsi), %rax
cmpq %rax, %rdx
je 0x13d90
movq %rdx, (%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rdi)
movq %rax, (%rsi)
jmp 0x13da1
movq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
movb (%rsi), %al
movb %al, (%rdi)
retq
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq (%rsi), %rax
movq $0x0, 0x8(%rsi)
movb $0x0, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13dda
cmpl $0x1, %eax
je 0x13dcd
testl %eax, %eax
jne 0x13deb
movq (%rbx), %rdi
callq 0x13df4
jmp 0x13dd5
movq (%rbx), %rdi
callq 0x13e08
movq (%rbx), %rdi
jmp 0x13de6
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x13deb
callq 0x4220
movl $0x7, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r8, %rbx
movl %ecx, %r8d
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x50(%rsp), %r12
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x14a95
testl %eax, %eax
je 0x14952
cmpl $-0x1, %eax
jne 0x14973
callq 0xdf1e
movl $0x8, (%rbx)
jmp 0x1495d
callq 0xdf1e
movl $0x4, (%rbx)
movq %rax, 0x8(%rbx)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movzbl 0x10(%rsp), %eax
movb $0x1, %bl
cmpl $0x2b, %eax
je 0x14963
cmpl $0x22, %eax
jne 0x149fd
leaq 0x11(%rsp), %rdx
movb (%rdx), %al
xorl %esi, %esi
cmpb $0x2d, %al
sete %sil
leaq 0x12(%rsp), %rcx
cmovneq %rdx, %rcx
movzbl 0x1(%rsi,%r15), %edx
cmpl $0x6e, %edx
je 0x14a3a
cmpl $0x69, %edx
jne 0x14963
subq %rcx, %r12
cmpq $0x4, %r12
jl 0x14963
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x6e, 0x2(%rcx,%r15)
jne 0x14963
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x66, 0x3(%rcx,%r15)
jne 0x14963
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x22, 0x4(%rcx,%r15)
jne 0x14963
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
leaq 0x2f6a8(%rip), %rax     # 0x440a0
jmp 0x14a8e
callq 0x4040
movq %rax, %r12
movl $0x0, (%rax)
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x41c0
cmpq %r15, (%r13)
je 0x14963
cmpl $0x22, (%r12)
je 0x14963
movsd %xmm0, (%r14)
jmp 0x14963
subq %rcx, %r12
cmpq $0x4, %r12
jl 0x14963
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x61, 0x2(%rcx,%r15)
jne 0x14963
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x6e, 0x3(%rcx,%r15)
jne 0x14963
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x22, 0x4(%rcx,%r15)
jne 0x14963
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
leaq 0x2f602(%rip), %rax     # 0x44090
movsd (%rax,%rcx,8), %xmm0
jmp 0x14a30
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq %rdx, %r13
cmpl $-0x1, %ebp
sete %bl
movq %r15, %rdi
callq 0x9cb2
movl %eax, %r14d
testq %r13, %r13
setne %al
andb %bl, %al
cmpb $0x1, %al
jne 0x150f8
movq 0x10(%r13), %rax
cmpq 0x18(%r13), %rax
jae 0x15147
cmpl $-0x1, %r14d
je 0x15109
jmp 0x15161
cmpl $-0x1, %r14d
sete %al
cmpl $-0x1, %ebp
sete %cl
cmpb %al, %cl
je 0x15161
movq %r15, %rdi
callq 0x9cb2
movzbl %al, %eax
leaq 0x2ff65(%rip), %rcx     # 0x45080
testb $0x4, (%rax,%rcx)
je 0x15161
movq (%r15), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x1513f
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, 0x8(%r15)  # imm = 0xFFFFFFFF
jmp 0x150c9
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x15135
movq (%r13), %rax
movq %r13, %rdi
callq *0x48(%rax)
cmpl $-0x1, %eax
jne 0x150f0
cmpl $-0x1, %r14d
je 0x15161
xorl %r13d, %r13d
jmp 0x15109
xorl %r13d, %r13d
cmpl $-0x1, %ebp
sete %bl
movq %r15, %rdi
callq 0x9cb2
movl %eax, %r14d
testq %r12, %r12
setne %al
andb %bl, %al
cmpb $0x1, %al
jne 0x15195
movq 0x10(%r12), %rax
cmpq 0x18(%r12), %rax
jae 0x151f5
cmpl $-0x1, %r14d
je 0x151a6
jmp 0x1520f
cmpl $-0x1, %r14d
sete %al
cmpl $-0x1, %ebp
sete %cl
cmpb %al, %cl
je 0x1520f
cmpq $0x4, %r13
je 0x15238
leaq 0x2f8f5(%rip), %rax     # 0x44aac
movb (%r13,%rax), %r14b
movq %r15, %rdi
callq 0x9cb2
cmpb %al, %r14b
jne 0x1521b
movq (%r15), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x151ed
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, 0x8(%r15)  # imm = 0xFFFFFFFF
incq %r13
jmp 0x15164
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x151dd
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
cmpl $-0x1, %eax
jne 0x1518d
cmpl $-0x1, %r14d
je 0x1520f
xorl %r12d, %r12d
jmp 0x151a6
leaq 0x2f896(%rip), %rax     # 0x44aac
movb (%r13,%rax), %r14b
testb %r14b, %r14b
je 0x15238
callq 0xdf1e
movq 0x8(%rsp), %rcx
movl $0x1, (%rcx)
movq %rax, 0x8(%rcx)
xorl %eax, %eax
jmp 0x15246
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x1699d
leaq 0x2e6f9(%rip), %rcx     # 0x45080
movzbl (%rax), %r8d
testb $0x4, (%r8,%rcx)
je 0x1699d
incq %rax
movq %rax, (%rsi)
cmpq %rdx, %rax
jne 0x16987
subq %rax, %rdx
cmpq $0x4, %rdx
jb 0x169c6
cmpl $0x65757274, (%rax)     # imm = 0x65757274
je 0x169d9
cmpq $0x4, %rdx
je 0x169c6
movl $0x736c6166, %ecx       # imm = 0x736C6166
xorl (%rax), %ecx
movzbl 0x4(%rax), %edx
xorl $0x65, %edx
orl %ecx, %edx
je 0x169e5
callq 0xdf1e
movl $0x5, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
jmp 0x169f1
addq $0x4, %rax
movq %rax, (%rsi)
movb $0x1, (%rdi)
jmp 0x169ef
addq $0x5, %rax
movq %rax, (%rsi)
movb $0x0, (%rdi)
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x16a1d
leaq 0x2e679(%rip), %rcx     # 0x45080
movzbl (%rax), %r8d
testb $0x4, (%r8,%rcx)
je 0x16a1d
incq %rax
movq %rax, (%rsi)
cmpq %rdx, %rax
jne 0x16a07
subq %rax, %rdx
cmpq $0x4, %rdx
jb 0x16a2e
cmpl $0x6c6c756e, (%rax)     # imm = 0x6C6C756E
je 0x16a41
callq 0xdf1e
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
addq $0x4, %rax
movq %rax, (%rsi)
movq $0x0, (%rdi)
movb $0x1, %al
jmp 0x16a3f
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<is_dynamic_type<std::unordered_map<cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>, cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>, std::hash<cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>>, std::equal_to<cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>> const, cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>>>>>::value && !std::integral_constant<bool, false>::value, cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>&>::type cxon::value::controller<cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>>::copy_assign<std::unordered_map<cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>, cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>, std::hash<cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>>, std::equal_to<cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>> const, cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>>>>>(cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>&, cxon::cbor::basic_node<test::kind::unordered_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 0x41dec
movq (%rbx), %rdi
callq 0x409a2
movq (%rbx), %rdi
movq (%r14), %rsi
xorl %eax, %eax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rdi)
movups 0x20(%rsi), %xmm0
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movq %rsp, %rdx
movq %rdi, (%rdx)
callq 0x41056
jmp 0x41e06
movq %rbx, %rdi
callq 0x4093c
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41000
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x16b3c
movq (%rbx), %rdi
leaq 0x10(%rbx), %r15
cmpq %r15, %rdi
je 0x16b4f
callq 0x4220
jmp 0x16b4f
movq %rbx, %rdi
callq 0x13dae
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x13922
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x8, %edx
ja 0x170c9
movl %edx, %eax
leaq 0x2d34f(%rip), %rcx     # 0x4437c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2d920(%rip), %rsi     # 0x4495d
leaq 0x2d921(%rip), %rdx     # 0x44965
jmp 0x170d7
leaq 0x2da61(%rip), %rsi     # 0x44ab1
leaq 0x2da69(%rip), %rdx     # 0x44ac0
jmp 0x170d7
leaq 0x2d967(%rip), %rsi     # 0x449c7
leaq 0x2d96f(%rip), %rdx     # 0x449d6
jmp 0x170d7
leaq 0x2da34(%rip), %rsi     # 0x44aa4
leaq 0x2da39(%rip), %rdx     # 0x44ab0
jmp 0x170d7
leaq 0x2da65(%rip), %rsi     # 0x44ae5
leaq 0x2da6b(%rip), %rdx     # 0x44af2
jmp 0x170d7
leaq 0x2d8d6(%rip), %rsi     # 0x44966
leaq 0x2d8df(%rip), %rdx     # 0x44976
jmp 0x170d7
leaq 0x2da21(%rip), %rsi     # 0x44ac1
leaq 0x2da30(%rip), %rdx     # 0x44ad7
jmp 0x170d7
leaq 0x2da28(%rip), %rsi     # 0x44ad8
leaq 0x2da2d(%rip), %rdx     # 0x44ae4
jmp 0x170d7
leaq 0x2da33(%rip), %rsi     # 0x44af3
leaq 0x2da37(%rip), %rdx     # 0x44afe
jmp 0x170d7
leaq 0x2d941(%rip), %rsi     # 0x44a11
leaq 0x2d947(%rip), %rdx     # 0x44a1e
movq %rbx, %rdi
callq 0x98ac
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::cbor::imp::read_unsigned_<cxon::cbor::format_traits, unsigned long long, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(unsigned long long&, 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 %rbx
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x171af
leaq 0x1(%rax), %r8
movq %r8, (%rsi)
movzbl (%rax), %ecx
andl $0x1f, %ecx
cmpb $0x18, %cl
jae 0x17110
movq %rcx, (%rdi)
movb $0x1, %al
jmp 0x171c3
movl %ecx, %r9d
addl $-0x18, %r9d
cmpl $0x4, %r9d
jae 0x171af
addl $-0x18, %ecx
movl $0x1, %r9d
shll %cl, %r9d
decl %r9d
cmpl $0x7, %r9d
ja 0x171af
leaq 0x2d263(%rip), %rcx     # 0x443a0
movslq (%rcx,%r9,4), %r9
addq %rcx, %r9
jmpq *%r9
cmpq %rdx, %r8
je 0x171af
movzbl 0x1(%rax), %ecx
movq %rcx, (%rdi)
addq $0x2, %rax
movq %rax, (%rsi)
jmp 0x17109
subq %r8, %rdx
cmpq $0x4, %rdx
jl 0x171af
leaq 0x5(%rax), %rcx
movq %rcx, (%rsi)
movl 0x1(%rax), %eax
bswapl %eax
jmp 0x171a7
subq %r8, %rdx
cmpq $0x2, %rdx
jl 0x171af
leaq 0x3(%rax), %rcx
movq %rcx, (%rsi)
movzwl 0x1(%rax), %eax
rolw $0x8, %ax
movzwl %ax, %eax
jmp 0x171a7
subq %r8, %rdx
cmpq $0x8, %rdx
jl 0x171af
leaq 0x9(%rax), %rcx
movq %rcx, (%rsi)
movq 0x1(%rax), %rax
bswapq %rax
movq %rax, (%rdi)
jmp 0x17109
movq %rax, (%rsi)
callq 0x16fd8
movl $0x4, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop