LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/string.hxx
// Function: bool cxon::cio::str::imp::char_read_<cxon::JSON<cxon::cio::str::raw_traits<cxon::json::format_traits>>, cxon::cnt::range_container<char*>, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>, char>(cxon::cnt::range_container<char*>&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
inline bool char_read_(C& c, II& i, II e, Cx& cx) {
                II const o = i;
                    char32_t const c32 = chr::utf8_to_utf32<X>(i, e, cx);
                        if (c32 == chr::bad_utf32) return rewind(i, o), false;
                return char_append_(c, c32) || (rewind(i, o), cx/X::read_error::overflow);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x18(%rbp)
movl %ecx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rcx
movq -0x58(%rbp), %rsi
movl -0x50(%rbp), %edx
callq 0x1e2d0
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
jne 0x1dcb4
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rsi
movl -0x60(%rbp), %edx
callq 0x1cfc0
movb $0x0, -0x1(%rbp)
jmp 0x1dd05
movq -0x20(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x1db30
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x79(%rbp)
jne 0x1dcfd
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x78(%rbp), %rsi
movl -0x70(%rbp), %edx
callq 0x1cfc0
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x1c2f0
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x18(%rbp)
movl %ecx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x115c0
movsbl %al, %eax
cmpl $0x7d, %eax
jne 0x1f221
movb $0x0, -0x1(%rbp)
jmp 0x1f335
movq -0x28(%rbp), %rdi
callq 0x115c0
movsbl %al, %eax
cmpl $0x5d, %eax
jne 0x1f23b
movb $0x0, -0x1(%rbp)
jmp 0x1f335
movq -0x28(%rbp), %rdi
callq 0x115c0
movsbl %al, %eax
cmpl $0x2c, %eax
jne 0x1f255
movb $0x0, -0x1(%rbp)
jmp 0x1f335
movq -0x28(%rbp), %rdi
callq 0x115c0
movsbl %al, %eax
cmpl $0x7b, %eax
jne 0x1f294
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdx
movl -0x30(%rbp), %ecx
callq 0x1f340
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1f335
movq -0x28(%rbp), %rdi
callq 0x115c0
movsbl %al, %eax
cmpl $0x5b, %eax
jne 0x1f2d0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdx
movl -0x40(%rbp), %ecx
callq 0x1f4e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1f335
movq -0x28(%rbp), %rdi
callq 0x115c0
movsbl %al, %eax
cmpl $0x22, %eax
jne 0x1f30c
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rdx
movl -0x50(%rbp), %ecx
callq 0x1f680
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1f335
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rdx
movl -0x60(%rbp), %ecx
callq 0x1f6f0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x18(%rbp)
movl %ecx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11590
testb $0x1, %al
jne 0x1f71a
jmp 0x1f796
movq -0x28(%rbp), %rdi
callq 0x115c0
movsbl %al, %eax
cmpl $0x7d, %eax
jne 0x1f731
movb $0x1, -0x1(%rbp)
jmp 0x1f79a
movq -0x28(%rbp), %rdi
callq 0x115c0
movsbl %al, %eax
cmpl $0x5d, %eax
jne 0x1f748
movb $0x1, -0x1(%rbp)
jmp 0x1f79a
movq -0x28(%rbp), %rdi
callq 0x115c0
movsbl %al, %eax
cmpl $0x2c, %eax
jne 0x1f75f
movb $0x1, -0x1(%rbp)
jmp 0x1f79a
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x115c0
movq -0x30(%rbp), %rdi
movsbl %al, %esi
callq 0x1f7b0
testb $0x1, %al
jne 0x1f786
movb $0x0, -0x1(%rbp)
jmp 0x1f79a
jmp 0x1f788
movq -0x28(%rbp), %rdi
callq 0x115f0
jmp 0x1f707
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x18(%rbp)
movl %ecx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x115c0
movq -0x30(%rbp), %rdi
movsbl %al, %esi
callq 0x1f7b0
testb $0x1, %al
jne 0x1f821
movb $0x0, -0x1(%rbp)
jmp 0x1f940
movq -0x28(%rbp), %rdi
callq 0x115f0
movq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11590
testb $0x1, %al
jne 0x1f840
jmp 0x1f93c
movq -0x28(%rbp), %rdi
callq 0x115c0
movsbl %al, %eax
movl %eax, -0x34(%rbp)
subl $0x22, %eax
je 0x1f8df
jmp 0x1f85a
movl -0x34(%rbp), %eax
subl $0x5c, %eax
jne 0x1f903
jmp 0x1f868
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x115c0
movq -0x40(%rbp), %rdi
movsbl %al, %esi
callq 0x1f7b0
testb $0x1, %al
jne 0x1f892
movb $0x0, -0x1(%rbp)
jmp 0x1f940
movq -0x28(%rbp), %rdi
callq 0x115f0
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1e020
testb $0x1, %al
jne 0x1f8ad
jmp 0x1f8b6
movb $0x0, -0x1(%rbp)
jmp 0x1f940
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x115c0
movq -0x48(%rbp), %rdi
movsbl %al, %esi
callq 0x1f7b0
testb $0x1, %al
jne 0x1f8dd
movb $0x0, -0x1(%rbp)
jmp 0x1f940
jmp 0x1f92c
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x115c0
movq -0x50(%rbp), %rdi
movsbl %al, %esi
callq 0x1f7b0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1f940
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0x115c0
movq -0x58(%rbp), %rdi
movsbl %al, %esi
callq 0x1f7b0
testb $0x1, %al
jne 0x1f92a
movb $0x0, -0x1(%rbp)
jmp 0x1f940
jmp 0x1f92c
jmp 0x1f92e
movq -0x28(%rbp), %rdi
callq 0x115f0
jmp 0x1f82a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, bool, void>::value<std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(bool&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(bool& t, II& i, II e, Cx& cx) {
                    static_assert(*X::id::pos != *X::id::neg, "boolean literals ambiguous"); // for input-iterator, id must be consumed
                    if (!cio::consume<X>(i, e, cx))
                        return false;
                    II const o = i;
                        char const c = cio::peek(i, e);
                            if (c == *X::id::pos && cio::consume<X>(X::id::pos, i, e)) return t = true,  true;
                            if (c == *X::id::neg && cio::consume<X>(X::id::neg, i, e)) return t = false, true;
                    return cio::rewind(i, o), cx/json::read_error::boolean_invalid;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x18(%rbp)
movl %ecx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rsi
movl -0x38(%rbp), %edx
callq 0x214e0
testb $0x1, %al
jne 0x2139f
movb $0x0, -0x1(%rbp)
jmp 0x214d1
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movl -0x60(%rbp), %esi
movq -0x78(%rbp), %rdx
movl -0x70(%rbp), %ecx
callq 0x1cee0
movb %al, -0x51(%rbp)
movsbl -0x51(%rbp), %eax
movsbl 0xa17a6(%rip), %ecx     # 0xc2b9c
cmpl %ecx, %eax
jne 0x2143d
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rdx
movl -0x80(%rbp), %ecx
leaq 0xa177a(%rip), %rdi     # 0xc2b9c
callq 0x21540
testb $0x1, %al
jne 0x2142d
jmp 0x2143d
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x214d1
movsbl -0x51(%rbp), %eax
movsbl 0xa1759(%rip), %ecx     # 0xc2ba1
cmpl %ecx, %eax
jne 0x21492
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x98(%rbp), %rdx
movl -0x90(%rbp), %ecx
leaq 0xa1727(%rip), %rdi     # 0xc2ba1
callq 0x21540
testb $0x1, %al
jne 0x21485
jmp 0x21492
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x214d1
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa8(%rbp), %rsi
movl -0xa0(%rbp), %edx
callq 0x1cfc0
movq -0x30(%rbp), %rdi
movl $0x5, %esi
callq 0x1c2f0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x26b70
testb $0x1, %al
jne 0x21e16
movq -0x10(%rbp), %rdi
callq 0x27670
movq -0x10(%rbp), %rdi
movl $0x0, 0x20(%rdi)
callq 0x27710
movq -0x10(%rbp), %rdi
callq 0x27730
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x22315
jmp 0x222fa
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x22360
jmp 0x22304
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x223ab
jmp 0x223f0
leaq -0x15(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x5670
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xa077a(%rip), %rsi     # 0xc2aab
callq 0x54f0
jmp 0x22338
leaq -0x15(%rbp), %rdi
callq 0x53f0
jmp 0x22435
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x53f0
jmp 0x2243f
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5670
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xa0835(%rip), %rsi     # 0xc2bb1
callq 0x54f0
jmp 0x22383
leaq -0x25(%rbp), %rdi
callq 0x53f0
jmp 0x22435
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x53f0
jmp 0x2243f
leaq -0x26(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5670
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0xa07f8(%rip), %rsi     # 0xc2bbf
callq 0x54f0
jmp 0x223ce
leaq -0x26(%rbp), %rdi
callq 0x53f0
jmp 0x22435
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x53f0
jmp 0x2243f
leaq -0x27(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5670
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xa0753(%rip), %rsi     # 0xc2b5f
callq 0x54f0
jmp 0x22413
leaq -0x27(%rbp), %rdi
callq 0x53f0
jmp 0x22435
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x27(%rbp), %rdi
callq 0x53f0
jmp 0x2243f
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5660
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x20(%rdi)
addq $0x24, %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
addq $0x24, %rsi
callq 0x23930
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x7, %rax
ja 0x23836
movq -0x28(%rbp), %rax
leaq 0x9e015(%rip), %rcx     # 0xc17ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23960
jmp 0x237af
jmp 0x23836
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x22ca0
jmp 0x2383c
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23990
jmp 0x237da
jmp 0x23836
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x239c0
jmp 0x237eb
jmp 0x23836
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x239f0
jmp 0x23836
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23a20
jmp 0x23836
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23a50
jmp 0x23836
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23a80
jmp 0x23836
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23ab0
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5660
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x20(%rdi)
addq $0x24, %rdi
movq -0x10(%rbp), %rsi
addq $0x24, %rsi
callq 0x22cc0
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x23922
movq -0x18(%rbp), %rax
leaq 0x9df29(%rip), %rcx     # 0xc17cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25810
jmp 0x23922
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25840
jmp 0x23922
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25870
jmp 0x23922
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x258a0
jmp 0x23922
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x258d0
jmp 0x23922
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25900
jmp 0x23922
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25930
jmp 0x23922
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25960
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x20(%rdi)
addq $0x24, %rdi
movq -0x18(%rbp), %rsi
callq 0x22cc0
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0x27602
movq -0x20(%rbp), %rax
leaq 0x9a289(%rip), %rcx     # 0xc180c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25810
jmp 0x27602
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25840
jmp 0x27602
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25870
jmp 0x27602
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x258a0
jmp 0x27602
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x258d0
jmp 0x27602
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25900
jmp 0x27602
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25930
jmp 0x27602
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25960
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x20(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x7, %rax
ja 0x276fb
movq -0x10(%rbp), %rax
leaq 0x9a190(%rip), %rcx     # 0xc182c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x27750
jmp 0x276fb
movq -0x18(%rbp), %rdi
callq 0x27770
jmp 0x276fb
movq -0x18(%rbp), %rdi
callq 0x27790
jmp 0x276fb
movq -0x18(%rbp), %rdi
callq 0x277b0
jmp 0x276fb
movq -0x18(%rbp), %rdi
callq 0x277d0
jmp 0x276fb
movq -0x18(%rbp), %rdi
callq 0x277f0
jmp 0x276fb
movq -0x18(%rbp), %rdi
callq 0x27810
jmp 0x276fb
movq -0x18(%rbp), %rdi
callq 0x27830
movq -0x18(%rbp), %rax
movl $0x7, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<is_dynamic_type<std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>::value, void>::type cxon::value::controller<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>::destruct<std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&)
static auto destruct(N& n) noexcept -> enable_if_t< is_dynamic_type<T>::value> {
                        using at = alc::rebind_t<allocator_type, T>;
                        at    al(n.alloc_);
                        std::allocator_traits<at>::destroy(al, get<T*>(n));
                        std::allocator_traits<at>::deallocate(al, get<T*>(n), 1);
                    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
addq $0x24, %rsi
leaq -0x9(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x23be0
movq -0x8(%rbp), %rdi
callq 0x23c30
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
callq 0x278c0
movq -0x8(%rbp), %rdi
callq 0x23c30
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0x278f0
jmp 0x278a2
leaq -0x9(%rbp), %rdi
callq 0x23c70
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xc1f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0x18(%rbp)
movl %ecx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x29aa0
movq -0xd8(%rbp), %rdi
movq %rax, -0xd0(%rbp)
callq 0x29ab0
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rdx
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movq -0x90(%rbp), %rcx
movl -0x88(%rbp), %r8d
callq 0x29d20
movl %eax, %ecx
movl %ecx, -0xc4(%rbp)
subl $-0x1, %eax
je 0x29c46
jmp 0x29c37
movl -0xc4(%rbp), %eax
testl %eax, %eax
je 0x29c87
jmp 0x29cc8
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xa0(%rbp), %rsi
movl -0x98(%rbp), %edx
callq 0x1cfc0
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x1c2f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x29d05
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xb0(%rbp), %rsi
movl -0xa8(%rbp), %edx
callq 0x1cfc0
movq -0x30(%rbp), %rdi
movl $0x4, %esi
callq 0x1c2f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x29d05
leaq -0x80(%rbp), %rdi
callq 0x29aa0
movq %rax, -0xe0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x29ab0
movq -0xe0(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x2a500
movq %rax, -0xc0(%rbp)
movl %edx, -0xb8(%rbp)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x18(%rbp)
movl %ecx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rsi
movl -0x38(%rbp), %edx
callq 0x214e0
testb $0x1, %al
jne 0x2af7f
movb $0x0, -0x1(%rbp)
jmp 0x2b00c
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rdx
movl -0x58(%rbp), %ecx
leaq 0x97c46(%rip), %rdi     # 0xc2bfa
callq 0x21540
testb $0x1, %al
jne 0x2afbf
jmp 0x2afd3
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, %al
testb $0x1, %al
movb %al, -0x71(%rbp)
jne 0x2b004
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rsi
movl -0x68(%rbp), %edx
callq 0x1cfc0
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x1c2f0
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2f320
testb $0x1, %al
jne 0x2f836
movb $0x0, -0x1(%rbp)
jmp 0x2f8e9
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x4, -0x38(%rbp)
cmpq $0x4, -0x30(%rbp)
jb 0x2f88f
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x93337(%rip), %rdi     # 0xc2b9c
movl $0x4, %edx
callq 0x13150
cmpl $0x0, %eax
jne 0x2f88f
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2f8e9
movq $0x5, -0x40(%rbp)
cmpq $0x5, -0x30(%rbp)
jb 0x2f8d6
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x932f5(%rip), %rdi     # 0xc2ba1
movl $0x5, %edx
callq 0x13150
cmpl $0x0, %eax
jne 0x2f8d6
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x5, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2f8e9
movq -0x28(%rbp), %rdi
movl $0x5, %esi
callq 0x2caf0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2f320
testb $0x1, %al
jne 0x2f973
movb $0x0, -0x1(%rbp)
jmp 0x2f9e7
movq $0x4, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x4, %rax
jb 0x2f9ce
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x9325d(%rip), %rdi     # 0xc2bfa
movl $0x4, %edx
callq 0x13150
cmpl $0x0, %eax
jne 0x2f9ce
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, %al
testb $0x1, %al
movb %al, -0x31(%rbp)
jne 0x2f9df
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x2caf0
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<is_dynamic_type<std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>::value && !std::integral_constant<bool, false>::value, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&>::type cxon::value::controller<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>::copy_assign<std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&)
static auto copy_assign(N& n, const N& o)
                        -> enable_if_t< is_dynamic_type<T>::value && !propagate_on_container_copy_assignment::value, N&>
                    {
                        if (n.kind_ == o.kind_) {
                            get<T>(n).~T();
                            alc::uninitialized_construct_using_allocator<T>(&get<T>(n), n.alloc_, get<T>(o));
                        }
                        else {
                            n.reset(), n.kind_ = o.kind_;
                            construct<T>(n, get<T>(o));
                        }
                        return n;
                    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x2fc05
movq -0x8(%rbp), %rdi
callq 0x27ee0
movq %rax, %rdi
callq 0x27940
movq -0x8(%rbp), %rdi
callq 0x27ee0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23bc0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x2fc50
jmp 0x2fc39
movq -0x8(%rbp), %rdi
callq 0x27670
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23bc0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x23b20
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<!is_dynamic_type<double>::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<double>(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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x2ffbf
movq -0x8(%rbp), %rdi
callq 0x253a0
movq -0x8(%rbp), %rdi
callq 0x253a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x253b0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x25370
jmp 0x2ffbd
jmp 0x3000c
movq -0x8(%rbp), %rdi
callq 0x27670
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x253a0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x253b0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x25370
jmp 0x3000a
jmp 0x3000c
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xc1f0
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::cbor::imp::read_integral_<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_integral_(T& t, II& i, II e, Cx& cx) {
                switch (bio::peek(i, e) & X::mjr) {
                    case 0x00:  return read_unsigned_<X>(t, i, e, cx);
                    case 0x20:  return read_signed_<X>(t, i, e, cx);
                    default:    return cx/cbor::read_error::integer_invalid;
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xff, %edx
callq 0x309a0
movzbl %al, %eax
andl $0xe0, %eax
movl %eax, -0x2c(%rbp)
je 0x31093
jmp 0x31089
movl -0x2c(%rbp), %eax
subl $0x20, %eax
je 0x310af
jmp 0x310cb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x31740
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x310de
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x31840
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x310de
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x31190
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xff, %edx
callq 0x310f0
movzbl %al, %eax
andl $0x1f, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
subl $0x18, %eax
jb 0x317a8
jmp 0x3178b
movl -0x38(%rbp), %eax
addl $-0x18, %eax
subl $0x4, %eax
jb 0x317b9
jmp 0x31798
movl -0x38(%rbp), %eax
addl $-0x1c, %eax
subl $0x4, %eax
jb 0x3180b
jmp 0x3182d
movslq -0x34(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x31831
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %ecx
subl $0x18, %ecx
movl $0x1, %esi
shll %cl, %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x318a0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x31801
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x31170
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x31190
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x31831
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x31170
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x31190
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x31831
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)