LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9bbc
cmpb $0x7d, %al
je 0xfe65
movq %r15, %rdi
callq 0x9bbc
cmpb $0x5d, %al
je 0xfe65
movq %r15, %rdi
callq 0x9bbc
cmpb $0x2c, %al
jne 0xfe73
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x9bbc
cmpb $0x7b, %al
jne 0xfe9a
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfef4
movq %r15, %rdi
callq 0x9bbc
cmpb $0x5b, %al
jne 0xfec1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1004c
movq %r15, %rdi
callq 0x9bbc
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
cmpb $0x22, %al
jne 0xfee8
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x101a4
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x101e2
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, (%rsp)
movq %rsi, %rdi
callq 0x9bbc
movq (%rbx), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x10039
incq %rax
movq %rax, 0x10(%rdi)
xorl %r13d, %r13d
cmpl $-0x1, %ebp
sete %r14b
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x9bbc
movl %eax, %r12d
testq %r15, %r15
setne %al
andb %r14b, %al
cmpb $0x1, %al
jne 0xff6f
movq 0x10(%r15), %rax
cmpq 0x18(%r15), %rax
jae 0xfffb
movzbl (%rax), %eax
cmpl $-0x1, %eax
jne 0xff71
xorl %r15d, %r15d
jmp 0xff71
movl %ebp, %eax
cmpl $-0x1, %r12d
sete %cl
cmpl $-0x1, %eax
sete %al
cmpb %al, %cl
je 0x10009
movq %rbx, %rdi
callq 0x9bbc
cmpb $0x22, %al
je 0xffbb
movzbl %al, %eax
movq %rbx, %rdi
cmpl $0x7d, %eax
je 0xffac
cmpl $0x7b, %eax
jne 0xffd2
callq 0x9bbc
incl %r13d
jmp 0xffd7
callq 0x9bbc
testl %r13d, %r13d
je 0x1001a
decl %r13d
jmp 0xffd7
movq (%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x102aa
testb %al, %al
jne 0xffd7
jmp 0x10009
callq 0x9bbc
movq (%rbx), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0xfff0
incq %rax
movq %rax, 0x10(%rdi)
jmp 0xff2e
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0xff2e
movq (%r15), %rax
movq %r15, %rdi
callq *0x48(%rax)
jmp 0xff65
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x10044
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
movb $0x1, %al
jmp 0x1000b
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0xff2b
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x1002e
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9bbc
movl %eax, %ebp
testq %r15, %r15
setne %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x10227
movq 0x10(%r15), %rax
cmpq 0x18(%r15), %rax
jae 0x10291
movzbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x10229
xorl %r15d, %r15d
jmp 0x10229
movl %ebx, %eax
cmpl $-0x1, %ebp
sete %bpl
cmpl $-0x1, %eax
sete %r12b
cmpb %r12b, %bpl
je 0x1029c
movq %r14, %rdi
callq 0x9bbc
cmpb $0x7d, %al
je 0x1029c
movq %r14, %rdi
callq 0x9bbc
cmpb $0x5d, %al
je 0x1029c
movq %r14, %rdi
callq 0x9bbc
cmpb $0x2c, %al
je 0x1029c
movq %r14, %rdi
callq 0x9bbc
movq (%r14), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x10289
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
jmp 0x101f2
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x1027c
movq (%r15), %rax
movq %r15, %rdi
callq *0x48(%rax)
jmp 0x1021d
xorb %r12b, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, %rdi
callq 0x9bbc
movq (%r14), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x10357
incq %rax
movq %rax, 0x10(%rdi)
cmpl $-0x1, %ebx
sete %r12b
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x9bbc
movl %eax, %ebp
testq %r15, %r15
setne %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x10317
movq 0x10(%r15), %rax
cmpq 0x18(%r15), %rax
jae 0x10362
movzbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x10319
xorl %r15d, %r15d
jmp 0x10319
movl %ebx, %eax
cmpl $-0x1, %ebp
sete %cl
cmpl $-0x1, %eax
sete %al
cmpb %al, %cl
je 0x103eb
movq %r14, %rdi
callq 0x9bbc
movl %eax, %ebp
movq %r14, %rdi
callq 0x9bbc
cmpb $0x5c, %bpl
je 0x1036d
movzbl %bpl, %eax
cmpl $0x22, %eax
jne 0x102c2
jmp 0x103ef
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x102da
movq (%r15), %rax
movq %r15, %rdi
callq *0x48(%rax)
jmp 0x1030d
movq (%r14), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x103d8
incq %rax
movq %rax, 0x10(%rdi)
cmpl $-0x1, %ebx
sete %r12b
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x9bbc
movl %eax, %ebp
testq %r15, %r15
setne %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x103be
movq 0x10(%r15), %rax
cmpq 0x18(%r15), %rax
jae 0x103e0
movzbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x103c0
xorl %r15d, %r15d
jmp 0x103c0
movl %ebx, %eax
cmpl $-0x1, %ebp
sete %cl
cmpl $-0x1, %eax
setne %al
xorb %cl, %al
jne 0x103eb
movq %r14, %rdi
jmp 0x102bd
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x10381
movq (%r15), %rax
movq %r15, %rdi
callq *0x48(%rax)
jmp 0x103b4
xorl %eax, %eax
jmp 0x103f1
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12553
movq %rbx, %rdi
callq 0x1359a
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)
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12609
cmpl $0x1, %edx
je 0x125f9
testl %edx, %edx
jne 0x12619
leaq 0x3542d(%rip), %rsi     # 0x47a1d
leaq 0x3542e(%rip), %rdx     # 0x47a25
jmp 0x12627
leaq 0x35523(%rip), %rsi     # 0x47b23
leaq 0x35529(%rip), %rdx     # 0x47b30
jmp 0x12627
leaq 0x35521(%rip), %rsi     # 0x47b31
leaq 0x35538(%rip), %rdx     # 0x47b4f
jmp 0x12627
leaq 0x354b1(%rip), %rsi     # 0x47ad1
leaq 0x354b7(%rip), %rdx     # 0x47ade
movq %rbx, %rdi
callq 0x97fc
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12a31
movq %r12, %rdi
callq 0x1359a
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 0x10490
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl 0x20(%rsi), %eax
cmpq $0x7, %rax
ja 0x12d88
movq %rdi, %rbx
leaq 0x34587(%rip), %rcx     # 0x47280
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rbx)
jmp 0x12d88
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 0x131ac
movq $0x0, (%rbx)
jmp 0x12d88
movsd (%rsi), %xmm0
movsd %xmm0, (%rbx)
jmp 0x12d88
movq (%rsi), %r14
movl $0x30, %edi
callq 0x4230
movq %rax, (%rbx)
leaq 0x6(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x12de0
jmp 0x12d88
movq (%rsi), %r14
movl $0x18, %edi
callq 0x4230
movq %rax, (%rbx)
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1306e
jmp 0x12d88
movb (%rsi), %al
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl 0x20(%rsi), %eax
cmpq $0x7, %rax
ja 0x12dd0
leaq 0x344fa(%rip), %rcx     # 0x472a0
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 0x13220
movq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
movb (%rsi), %al
movb %al, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x132b9
cmpl $0x6, %eax
ja 0x132d5
movl %eax, %eax
leaq 0x34036(%rip), %rcx     # 0x472c0
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 0x1330f
jmp 0x132bc
movq (%rdi), %rax
cmpq (%rsi), %rax
setl %al
popq %rcx
retq
callq 0x4030
shrl $0x1f, %eax
jmp 0x132bc
movsd (%rsi), %xmm0
ucomisd (%rdi), %xmm0
seta %al
jmp 0x132bc
xorl %eax, %eax
jmp 0x132bc
movq (%rdi), %rax
movq (%rsi), %rcx
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
callq 0x1340a
jmp 0x132bc
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x13300
movb (%rdi), %al
cmpb (%rsi), %al
setb %al
jmp 0x132bc
jmp 0x13307
movq %rax, %rdi
callq 0x8424
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl 0x20(%rsi), %eax
cmpq $0x7, %rax
ja 0x1358a
leaq 0x33d7c(%rip), %rcx     # 0x472dc
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 0x13220
movq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
movb (%rsi), %al
movb %al, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x135c6
cmpl $0x1, %eax
je 0x135b9
testl %eax, %eax
jne 0x135d7
movq (%rbx), %rdi
callq 0x135e0
jmp 0x135c1
movq (%rbx), %rdi
callq 0x135f4
movq (%rbx), %rdi
jmp 0x135d2
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x135d7
callq 0x4220
movl $0x7, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14b8a
testl %eax, %eax
je 0x14a47
cmpl $-0x1, %eax
jne 0x14a68
callq 0xcf7a
movl $0x8, (%rbx)
jmp 0x14a52
callq 0xcf7a
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 0x14a58
cmpl $0x22, %eax
jne 0x14af2
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 0x14b2f
cmpl $0x69, %edx
jne 0x14a58
subq %rcx, %r12
cmpq $0x4, %r12
jl 0x14a58
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x6e, 0x2(%rcx,%r15)
jne 0x14a58
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x66, 0x3(%rcx,%r15)
jne 0x14a58
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x22, 0x4(%rcx,%r15)
jne 0x14a58
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
leaq 0x32583(%rip), %rax     # 0x47070
jmp 0x14b83
callq 0x4040
movq %rax, %r12
movl $0x0, (%rax)
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x41c0
cmpq %r15, (%r13)
je 0x14a58
cmpl $0x22, (%r12)
je 0x14a58
movsd %xmm0, (%r14)
jmp 0x14a58
subq %rcx, %r12
cmpq $0x4, %r12
jl 0x14a58
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x61, 0x2(%rcx,%r15)
jne 0x14a58
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x6e, 0x3(%rcx,%r15)
jne 0x14a58
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
cmpb $0x22, 0x4(%rcx,%r15)
jne 0x14a58
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
leaq 0x324dd(%rip), %rax     # 0x47060
movsd (%rax,%rcx,8), %xmm0
jmp 0x14b25
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x10(%rsp)
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq %rdx, %r13
cmpl $-0x1, %ebp
sete %bl
movq %r15, %rdi
callq 0x9bbc
movl %eax, %r14d
testq %r13, %r13
setne %al
andb %bl, %al
cmpb $0x1, %al
jne 0x15e99
movq 0x10(%r13), %rax
cmpq 0x18(%r13), %rax
jae 0x15eea
movzbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x15e9b
xorl %r13d, %r13d
jmp 0x15e9b
movl %ebp, %eax
cmpl $-0x1, %r14d
sete %cl
cmpl $-0x1, %eax
sete %al
xorb %cl, %al
je 0x15ef6
movq %r15, %rdi
callq 0x9bbc
movzbl %al, %eax
leaq 0x32282(%rip), %rcx     # 0x48140
testb $0x4, (%rax,%rcx)
je 0x15ef6
movq (%r15), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x15ee2
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, 0x8(%r15)  # imm = 0xFFFFFFFF
jmp 0x15e65
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x15ed8
movq (%r13), %rax
movq %r13, %rdi
callq *0x48(%rax)
jmp 0x15e8f
xorl %r14d, %r14d
cmpl $-0x1, %ebp
sete %bl
movq %r15, %rdi
callq 0x9bbc
movl %eax, %r13d
testq %r12, %r12
setne %al
andb %bl, %al
cmpb $0x1, %al
jne 0x15f2f
movq 0x10(%r12), %rax
cmpq 0x18(%r12), %rax
jae 0x15f8f
movzbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x15f31
xorl %r12d, %r12d
jmp 0x15f31
movl %ebp, %eax
leaq 0x31c34(%rip), %rcx     # 0x47b6c
leaq (%rcx,%r14), %rbx
cmpl $-0x1, %r13d
sete %cl
cmpl $-0x1, %eax
sete %al
cmpb %al, %cl
je 0x15fa2
cmpq $0x4, %r14
je 0x15f9b
movb (%rbx), %r13b
movq %r15, %rdi
callq 0x9bbc
cmpb %al, %r13b
jne 0x15fa2
movq (%r15), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x15f87
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, 0x8(%r15)  # imm = 0xFFFFFFFF
incq %r14
jmp 0x15ef9
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x15f77
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
jmp 0x15f25
leaq 0x31bce(%rip), %rbx     # 0x47b70
movb (%rbx), %bl
testb %bl, %bl
je 0x15fbe
callq 0xcf7a
movq 0x10(%rsp), %rcx
movl $0x1, (%rcx)
movq %rax, 0x8(%rcx)
jmp 0x15fca
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
testb %bl, %bl
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x178ef
leaq 0x30867(%rip), %rcx     # 0x48140
movzbl (%rax), %r8d
testb $0x4, (%r8,%rcx)
je 0x178ef
incq %rax
movq %rax, (%rsi)
cmpq %rdx, %rax
jne 0x178d9
movq (%rsi), %rax
subq %rax, %rdx
cmpq $0x4, %rdx
jb 0x17903
cmpl $0x65757274, (%rax)     # imm = 0x65757274
je 0x1792e
cmpq $0x5, %rdx
jb 0x1791b
movl $0x736c6166, %ecx       # imm = 0x736C6166
xorl (%rax), %ecx
movzbl 0x4(%rax), %edx
xorl $0x65, %edx
orl %ecx, %edx
je 0x1793a
callq 0xcf7a
movl $0x5, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
jmp 0x17946
addq $0x4, %rax
movq %rax, (%rsi)
movb $0x1, (%rdi)
jmp 0x17944
addq $0x5, %rax
movq %rax, (%rsi)
movb $0x0, (%rdi)
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17971
leaq 0x307e5(%rip), %rcx     # 0x48140
movzbl (%rax), %r8d
testb $0x4, (%r8,%rcx)
je 0x17971
incq %rax
movq %rax, (%rsi)
cmpq %rdx, %rax
jne 0x1795b
movq (%rsi), %rax
subq %rax, %rdx
cmpq $0x4, %rdx
jb 0x17985
cmpl $0x6c6c756e, (%rax)     # imm = 0x6C6C756E
je 0x17998
callq 0xcf7a
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 0x17996
// File: /workspace/github_cpp_makefile_star2_O1/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 0x451b6
movq (%rbx), %rdi
callq 0x43d1e
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 0x4438a
jmp 0x451d0
movq %rbx, %rdi
callq 0x43cb8
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x44334
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17a92
movq (%rbx), %rdi
leaq 0x10(%rbx), %r15
cmpq %r15, %rdi
je 0x17aa5
callq 0x4220
jmp 0x17aa5
movq %rbx, %rdi
callq 0x1359a
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 0x131ac
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1806f
movl %edx, %eax
leaq 0x2f3c9(%rip), %rcx     # 0x4739c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2fa3a(%rip), %rsi     # 0x47a1d
leaq 0x2fa3b(%rip), %rdx     # 0x47a25
jmp 0x1807d
leaq 0x2fb7b(%rip), %rsi     # 0x47b71
leaq 0x2fb83(%rip), %rdx     # 0x47b80
jmp 0x1807d
leaq 0x2fa81(%rip), %rsi     # 0x47a87
leaq 0x2fa89(%rip), %rdx     # 0x47a96
jmp 0x1807d
leaq 0x2fb4e(%rip), %rsi     # 0x47b64
leaq 0x2fb53(%rip), %rdx     # 0x47b70
jmp 0x1807d
leaq 0x2fb7f(%rip), %rsi     # 0x47ba5
leaq 0x2fb85(%rip), %rdx     # 0x47bb2
jmp 0x1807d
leaq 0x2f9f0(%rip), %rsi     # 0x47a26
leaq 0x2f9f9(%rip), %rdx     # 0x47a36
jmp 0x1807d
leaq 0x2fb3b(%rip), %rsi     # 0x47b81
leaq 0x2fb4a(%rip), %rdx     # 0x47b97
jmp 0x1807d
leaq 0x2fb42(%rip), %rsi     # 0x47b98
leaq 0x2fb47(%rip), %rdx     # 0x47ba4
jmp 0x1807d
leaq 0x2fb4d(%rip), %rsi     # 0x47bb3
leaq 0x2fb51(%rip), %rdx     # 0x47bbe
jmp 0x1807d
leaq 0x2fa5b(%rip), %rsi     # 0x47ad1
leaq 0x2fa61(%rip), %rdx     # 0x47ade
movq %rbx, %rdi
callq 0x97fc
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %r8
cmpq %rdx, %r8
je 0x180a5
leaq 0x1(%r8), %rax
movq %rax, (%rsi)
movb (%r8), %cl
andb $0x1f, %cl
jmp 0x180a7
movb $0x1f, %cl
movzbl %cl, %eax
cmpb $0x18, %al
jae 0x180b5
movq %rax, (%rdi)
movb $0x1, %al
popq %rbx
retq
addl $-0x18, %eax
cmpl $0x4, %eax
jae 0x1816b
addb $-0x18, %cl
movl $0x1, %eax
shll %cl, %eax
decl %eax
cmpl $0x7, %eax
ja 0x1816b
leaq 0x2f2e3(%rip), %rcx     # 0x473c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
cmpq %rdx, %rax
setne %cl
je 0x18161
movzbl (%rax), %ecx
movq %rcx, (%rdi)
incq %rax
movq %rax, (%rsi)
jmp 0x180b1
movq (%rsi), %rax
subq %rax, %rdx
cmpq $0x4, %rdx
setge %cl
jl 0x18161
leaq 0x4(%rax), %rcx
movq %rcx, (%rsi)
movl (%rax), %eax
bswapl %eax
jmp 0x180ae
movq (%rsi), %rax
subq %rax, %rdx
cmpq $0x2, %rdx
setge %cl
jl 0x18161
leaq 0x2(%rax), %rcx
movq %rcx, (%rsi)
movzwl (%rax), %eax
rolw $0x8, %ax
movzwl %ax, %eax
jmp 0x180ae
movq (%rsi), %rax
subq %rax, %rdx
cmpq $0x8, %rdx
setge %cl
jl 0x18161
leaq 0x8(%rax), %rcx
movq %rcx, (%rsi)
movq (%rax), %rax
bswapq %rax
jmp 0x180ae
movb $0x1, %al
testb %cl, %cl
jne 0x180b3
movq %r8, (%rsi)
callq 0x17f7e
movl $0x4, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
jmp 0x180b3
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_b_fix_<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 bool read_array_b_fix_(T& t, II& i, II e, Cx& cx) {
                std::size_t n;
                return  read_size_le<X>(n, t.max_size() - size_(t), i, e, cx) &&
                        cxon::cnt::reserve(t, size_(t) + n) &&
                        read_bytes_<X>(t, n, i, e, cx)
                ;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rbp
movq 0x8(%rdi), %r13
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x18863
testb %al, %al
je 0x187c0
subq %rbp, %r13
sarq $0x3, %r13
movabsq $0x3333333333333333, %rax # imm = 0x3333333333333333
imulq %r13, %rax
movabsq $0x333333333333333, %rcx # imm = 0x333333333333333
addq %rax, %rcx
movq 0x10(%rsp), %r13
movb $0x1, %al
cmpq %rcx, %r13
ja 0x187cf
jmp 0x187e8
callq 0x17f7e
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rax
movq %rax, (%r15)
callq 0x17f7e
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
testb %al, %al
je 0x18850
movq 0x8(%r12), %rax
subq (%r12), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0x1895e
movq (%r15), %rdx
subq %rdx, %r14
cmpq %r13, %r14
movq %r13, %rbp
cmovbq %r14, %rbp
leaq (%rdx,%rbp), %rcx
movq 0x8(%r12), %rsi
movq %r12, %rdi
callq 0x18a3a
addq %rbp, (%r15)
cmpq %r13, %r14
setae %bpl
jae 0x18852
callq 0x17f7e
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x18852
xorl %ebp, %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_O1/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::operator=(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&&)
basic_node& operator =(basic_node&& o)
                noexcept(value::is_nothrow_move_assignable<basic_node>::value)
            {
                switch (o.kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: return value::move_assign<T>(*this, std::move(o))
                        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
                }
                return *this; // LCOV_EXCL_LINE
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rsi), %eax
cmpq $0x7, %rax
ja 0x18db9
movq %rsi, %r14
leaq 0x2e73a(%rip), %rcx     # 0x47440
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
cmpl %eax, 0x20(%rbx)
je 0x18d23
movq %rbx, %rdi
callq 0x1359a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
jmp 0x18db9
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18e5c
cmpl %eax, 0x20(%rbx)
je 0x18d54
movq %rbx, %rdi
callq 0x1359a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq $0x0, (%rbx)
jmp 0x18db9
cmpl %eax, 0x20(%rbx)
je 0x18d71
movq %rbx, %rdi
callq 0x1359a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
jmp 0x18db9
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18dc4
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18e10
cmpl %eax, 0x20(%rbx)
je 0x18db4
movq %rbx, %rdi
callq 0x1359a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movb (%r14), %al
movb %al, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq