LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: std::enable_if<std::is_integral<unsigned long long>::value, bool>::type cxon::bio::get<unsigned long long, char const*>(unsigned long long&, unsigned int, char const*&, char const*)
inline auto get(T& t, unsigned n, II& i, II e)
            -> enable_if_t<std::is_integral<T>::value, bool>
        {
            switch (n) {
                case 1:     return imp::get_<1>(t, i, e);
                case 2:     return imp::get_<2>(t, i, e);
                case 4:     return imp::get_<4>(t, i, e);
                case 8:     return imp::get_<8>(t, i, e);
                default:    return CXON_ASSERT(0, "unexpected"), false; // LCOV_EXCL_LINE
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x7, %eax
ja 0x3193b
movq -0x30(%rbp), %rax
leaq 0x903f6(%rip), %rcx     # 0xc1cc8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x31950
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3193f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x319a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3193f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x31a00
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3193f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x31a60
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3193f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: bool cxon::bio::imp::be_to_i_<unsigned long long, char const*>(cxon::bio::imp::buffer_<4u, char const*, is_random_access_iterator<char const*>::value> const&, unsigned long long&)
inline bool be_to_i_(const buffer_<4, II>& bs, T& t) {
                using R = std::uint_fast32_t;
                R const x = (R(bs[3])<< 0) | (R(bs[2])<< 8) |
                            (R(bs[1])<<16) | (R(bs[0])<<24) ;
                CXON_ASSERT(sizeof(T) >= 4, "narrowing");
                return sizeof(T) >= 4 && (t = T(x), true);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x31da0
movzbl %al, %eax
shlq $0x0, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x31da0
movb %al, %cl
movq -0x30(%rbp), %rax
movzbl %cl, %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x31da0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x31da0
movb %al, %cl
movq -0x20(%rbp), %rax
movzbl %cl, %ecx
shlq $0x18, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: bool cxon::bio::imp::be_to_i_<unsigned long long, char const*>(cxon::bio::imp::buffer_<8u, char const*, is_random_access_iterator<char const*>::value> const&, unsigned long long&)
inline bool be_to_i_(const buffer_<8, II>& bs, T& t) {
                using R = std::uint_fast64_t;
                R const x = (R(bs[7])<< 0) | (R(bs[6])<< 8) |
                            (R(bs[5])<<16) | (R(bs[4])<<24) |
                            (R(bs[3])<<32) | (R(bs[2])<<40) |
                            (R(bs[1])<<48) | (R(bs[0])<<56) ;
                CXON_ASSERT(sizeof(T) >= 8, "narrowing"); // LCOV_EXCL_LINE
                return sizeof(T) >= 8 && (t = T(x), true);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x7, %esi
callq 0x31fa0
movzbl %al, %eax
shlq $0x0, %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x31fa0
movb %al, %cl
movq -0x50(%rbp), %rax
movzbl %cl, %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x31fa0
movb %al, %cl
movq -0x48(%rbp), %rax
movzbl %cl, %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x31fa0
movb %al, %cl
movq -0x40(%rbp), %rax
movzbl %cl, %ecx
shlq $0x18, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x31fa0
movb %al, %cl
movq -0x38(%rbp), %rax
movzbl %cl, %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x31fa0
movb %al, %cl
movq -0x30(%rbp), %rax
movzbl %cl, %ecx
shlq $0x28, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x31fa0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
shlq $0x30, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x31fa0
movb %al, %cl
movq -0x20(%rbp), %rax
movzbl %cl, %ecx
shlq $0x38, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::read_array<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_array(T& t, II& i, II e, Cx& cx) {
            typename X::tag_type tag;
            if (!tag::read<X>(tag, i, e, cx))
                return false;
            return read_array<X>(t, tag, i, e, cx);
        }

// 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), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0x32720
testb $0x1, %al
jne 0x326f7
movb $0x0, -0x1(%rbp)
jmp 0x32715
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x32870
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: std::enable_if<std::is_assignable<decltype(*std::begin(fp)), decltype(*fp0)>::value, bool>::type cxon::cbor::cnt::imp::read_array_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline auto read_array_(T& t, II& i, II e, Cx& cx)
                -> enable_if_t< std::is_assignable<decltype(*std::begin(t)), decltype(*i)>::value, bool>
            {
                auto const m = bio::peek(i, e);
                switch (m & X::mjr) {
                    case X::bstr: case X::tstr: return imp::read_array_b_<X>(t, m, i, e, cx);
                    case X::arr:                return imp::read_array_w_<X>(t, m, i, e, cx);
                    default:                    return cx/cbor::read_error::array_invalid;
                }
            }

// Assembly:
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
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
andl $-0x20, %eax
movl %eax, -0x30(%rbp)
subl $0x40, %eax
je 0x32d64
jmp 0x32d4e
movl -0x30(%rbp), %eax
subl $0x60, %eax
je 0x32d64
jmp 0x32d58
movl -0x30(%rbp), %eax
subl $0x80, %eax
je 0x32d86
jmp 0x32da8
movq -0x10(%rbp), %rdi
movb -0x29(%rbp), %al
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movzbl %al, %esi
callq 0x32dd0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x32dbb
movq -0x10(%rbp), %rdi
movb -0x29(%rbp), %al
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movzbl %al, %esi
callq 0x32e70
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x32dbb
movq -0x28(%rbp), %rdi
movl $0x7, %esi
callq 0x31190
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_b_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, unsigned char, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_array_b_(T& t, bio::byte m, II& i, II e, Cx& cx) {
                switch (m & X::mnr) {
                    case 0x1C: case 0x1D: case 0x1E:    return cx/cbor::read_error::size_invalid;
                    case 0x1F:                          return read_array_b_var_<X>(t, i, e, cx);
                    default:                            return read_array_b_fix_<X>(t, i, e, cx);
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x34(%rbp)
addl $-0x1c, %eax
subl $0x3, %eax
jb 0x32e0c
jmp 0x32e02
movl -0x34(%rbp), %eax
subl $0x1f, %eax
je 0x32e21
jmp 0x32e3d
movq -0x30(%rbp), %rdi
movl $0x6, %esi
callq 0x31190
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x32e57
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x32f10
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x32e57
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x32fe0
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/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_w_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, unsigned char, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_array_w_(T& t, bio::byte m, II& i, II e, Cx& cx) {
                switch (m & X::mnr) {
                    case 0x1C: case 0x1D: case 0x1E:    return cx/cbor::read_error::size_invalid;
                    case 0x1F:                          return imp::read_array_w_var_<X>(t, i, e, cx);
                    default:                            return imp::read_array_w_fix_<X>(t, i, e, cx);
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x34(%rbp)
addl $-0x1c, %eax
subl $0x3, %eax
jb 0x32eac
jmp 0x32ea2
movl -0x34(%rbp), %eax
subl $0x1f, %eax
je 0x32ec1
jmp 0x32edd
movq -0x30(%rbp), %rdi
movl $0x6, %esi
callq 0x31190
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x32ef7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x34fa0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x32ef7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x350a0
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/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_b_var_<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_var_(T& t, II& i, II e, Cx& cx) {
                bio::byte const m = bio::get(i, e) & X::mjr;
                    for (auto b = bio::peek(i, e, 0); b != X::brk; b = bio::peek(i, e, 0)) {
                        if (m != (b & X::mjr))
                            return cx/cbor::read_error::array_invalid;
                        if (!read_array_b_fix_<X>(t, i, e, cx))
                            return false;
                    }
                return bio::get(i, e, 0), true;
            }

// 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 0x310f0
movzbl %al, %eax
andl $0xe0, %eax
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x309a0
movb %al, -0x2a(%rbp)
movzbl -0x2a(%rbp), %eax
cmpl $0xff, %eax
je 0x32fbe
movzbl -0x29(%rbp), %eax
movzbl -0x2a(%rbp), %ecx
andl $0xe0, %ecx
cmpl %ecx, %eax
je 0x32f89
movq -0x28(%rbp), %rdi
movl $0x7, %esi
callq 0x31190
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x32fd1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x32fe0
testb $0x1, %al
jne 0x32fa8
movb $0x0, -0x1(%rbp)
jmp 0x32fd1
jmp 0x32faa
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x309a0
movb %al, -0x2a(%rbp)
jmp 0x32f57
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x310f0
movb $0x1, -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/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x288f0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33120
movq -0x38(%rbp), %rsi
subq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq -0x28(%rbp), %rdi
callq 0x33090
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x33038
jmp 0x33083
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33120
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq -0x28(%rbp), %rsi
callq 0x33140
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x33067
jmp 0x33083
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x33170
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
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>>>::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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0x3439c
movq -0x20(%rbp), %rax
leaq 0x8da30(%rip), %rcx     # 0xc1d28
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x343b0
movq %rax, -0x8(%rbp)
jmp 0x343a4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x343e0
movq %rax, -0x8(%rbp)
jmp 0x343a4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34410
movq %rax, -0x8(%rbp)
jmp 0x343a4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34440
movq %rax, -0x8(%rbp)
jmp 0x343a4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34470
movq %rax, -0x8(%rbp)
jmp 0x343a4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x344a0
movq %rax, -0x8(%rbp)
jmp 0x343a4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x344d0
movq %rax, -0x8(%rbp)
jmp 0x343a4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34500
movq %rax, -0x8(%rbp)
jmp 0x343a4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// 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, true>::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>>>>::move_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>>>&&)
static auto move_assign(N& n, N&& o) noexcept
                        -> enable_if_t< is_dynamic_type<T>::value &&  propagate_on_container_move_assignment::value, N&>
                    {
                        if (n.kind_ == o.kind_) {
                            destruct<T>(n), n.alloc_ = std::move(o.alloc_);
                            get<T*>(n) = get<T*>(o), o.kind_ = N::kind_default_;
                        }
                        else {
                            n.reset(), n.kind_ = o.kind_, n.alloc_ = std::move(o.alloc_);
                            get<T*>(n) = get<T*>(o), o.kind_ = N::kind_default_;
                        }
                        return n;
                    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %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 0x34586
movq -0x8(%rbp), %rdi
callq 0x27850
movq -0x10(%rbp), %rdi
callq 0x23c30
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x23c30
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x7, 0x20(%rax)
jmp 0x345c8
movq -0x8(%rbp), %rdi
callq 0x27670
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x23c30
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x23c30
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x7, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::value && std::integral_constant<bool, true>::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>>>>::move_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>>>&&)
static auto move_assign(N& n, N&& o) noexcept(std::is_nothrow_move_constructible<T>::value)
                        -> enable_if_t<!is_dynamic_type<T>::value &&  propagate_on_container_move_assignment::value, N&>
                    {
                        if (n.kind_ == o.kind_) {
                            get<T>(n).~T(), n.alloc_ = std::move(o.alloc_);
                            alc::uninitialized_construct_using_allocator<T>(&get<T>(n), n.alloc_, std::move(get<T>(o)));
                        }
                        else {
                            n.reset(), n.kind_ = o.kind_, n.alloc_ = std::move(o.alloc_);
                            alc::uninitialized_construct_using_allocator<T>(&get<T>(n), n.alloc_, std::move(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 0x346f7
movq -0x8(%rbp), %rdi
callq 0x25220
movq %rax, %rdi
callq 0x5260
movq -0x8(%rbp), %rdi
callq 0x25220
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25220
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x25a90
jmp 0x346f5
jmp 0x34744
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 0x25220
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25220
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x25a90
jmp 0x34742
jmp 0x34744
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xc1f0
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_w_var_<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_w_var_(T& t, II& i, II e, Cx& cx) {
                II const o = i;
                    for (bio::get(i, e); size_(t) < t.max_size() && bio::peek(i, e, 0) != X::brk; )
                        if (!cxon::cnt::element_read<X>(t, i, e, cx))
                            return false;
                return  (bio::get(i, e, 0) == X::brk) ||
                        (bio::rewind(i, o), cx/cbor::read_error::size_invalid)
                ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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
movq -0x10(%rbp), %rdi
callq 0x33120
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x288f0
movq -0x40(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x31(%rbp)
jae 0x35019
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x309a0
movzbl %al, %eax
cmpl $0xff, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x35022
jmp 0x35043
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x35140
testb $0x1, %al
jne 0x35041
movb $0x0, -0x1(%rbp)
jmp 0x35088
jmp 0x34fd5
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x310f0
movzbl %al, %ecx
movb $0x1, %al
cmpl $0xff, %ecx
movb %al, -0x41(%rbp)
je 0x35080
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x31170
movq -0x28(%rbp), %rdi
movl $0x6, %esi
callq 0x31190
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_w_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_w_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, n) &&
                        read_elements_<X>(t, n, i, e, cx)
                ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x288f0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33120
movq -0x38(%rbp), %rsi
subq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq -0x28(%rbp), %rdi
callq 0x33090
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x350f8
jmp 0x3512f
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x33140
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x35113
jmp 0x3512f
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x351c0
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: std::enable_if<!std::is_assignable<decltype(*std::begin(fp)), decltype(*fp0)>::value, bool>::type cxon::cbor::cnt::imp::read_array_<cxon::CBOR<cxon::cbor::format_traits>, std::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>>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(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>>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline auto read_array_(T& t, II& i, II e, Cx& cx)
                -> enable_if_t<!std::is_assignable<decltype(*std::begin(t)), decltype(*i)>::value, bool>
            {
                auto const m = bio::peek(i, e);
                switch (m & X::mjr) {
                    case X::arr: case X::map:   return imp::read_array_w_<X>(t, m, i, e, cx);
                    default:                    return cx/cbor::read_error::array_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
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
orl $0x20, %eax
andl $0xe0, %eax
subl $0xa0, %eax
je 0x36442
jmp 0x36464
movq -0x10(%rbp), %rdi
movb -0x29(%rbp), %al
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movzbl %al, %esi
callq 0x36490
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x36477
movq -0x28(%rbp), %rdi
movl $0x7, %esi
callq 0x31190
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/imp/map.hxx
// Function: bool cxon::cbor::imp::map_element_reader_<cxon::CBOR<cxon::cbor::format_traits>, 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>>>>>>>::read<char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(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>>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool read(M& t, II& i, II e, Cx& cx) {
                    typename M::key_type    k = alc::create_using_allocator_of<typename M::key_type>(t);
                    typename M::mapped_type v = alc::create_using_allocator_of<typename M::mapped_type>(t);
                    return  read_value<X>(k, i, e, cx) &&
                            read_value<X>(cxon::cnt::emplace(t, std::move(k), std::move(v)).second, i, e, cx)
                    ;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x22a20
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x22a20
jmp 0x36857
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x30470
movb %al, -0x7d(%rbp)
jmp 0x36871
movb -0x7d(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x7e(%rbp)
jne 0x36880
jmp 0x368c9
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x22ae0
movq %rax, -0x88(%rbp)
jmp 0x3689a
movq -0x88(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x30470
movb %al, -0x89(%rbp)
jmp 0x368be
movb -0x89(%rbp), %al
movb %al, -0x7e(%rbp)
jmp 0x368c9
movb -0x7e(%rbp), %al
movb %al, -0x8a(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xaf00
leaq -0x48(%rbp), %rdi
callq 0xaf00
movb -0x8a(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x36918
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xaf00
leaq -0x48(%rbp), %rdi
callq 0xaf00
movq -0x78(%rbp), %rdi
callq 0x5660
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::read<cxon::CBOR<cxon::cbor::format_traits>, bool, void>::value<char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(bool&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool value(bool& t, II& i, II e, Cx& cx) {
                    II const o = i;
                        auto const b = bio::get(i, e);
                    return  ((b == X::neg || b == X::pos) && (t = bool(b - X::neg),  true)) ||
                            (bio::rewind(i, o), cx/cbor::read_error::boolean_invalid)
                    ;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xff, %edx
callq 0x310f0
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0xf4, %eax
je 0x36a3e
movzbl -0x29(%rbp), %eax
cmpl $0xf5, %eax
jne 0x36a5f
movzbl -0x29(%rbp), %eax
subl $0xf4, %eax
cmpl $0x0, %eax
setne %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, %al
testb $0x1, %al
movb %al, -0x2a(%rbp)
jne 0x36a7d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x31170
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x31190
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: double cxon::bio::imp::be_to_fp_<double, char const*>(cxon::bio::imp::buffer_<2u, char const*, is_random_access_iterator<char const*>::value> const&)
inline T be_to_fp_(const buffer_<2, II>& bs) {
                // TODO: not correct, but as in RFC7049 Appendix D
                const unsigned half = (bs[0] << 8) + bs[1];
                const unsigned exp = (half >> 10) & 0x1f;
                const unsigned mant = half & 0x3ff;
                double val;
                     if (exp == 0)  val = std::ldexp(mant, -24);
                else if (exp != 31) val = std::ldexp(mant + 1024, exp - 25);
                else                val = mant == 0 ? INFINITY : NAN;
                return (T)(half & 0x8000 ? -val : val);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x31c20
movzbl %al, %eax
shll $0x8, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x31c20
movb %al, %cl
movl -0x24(%rbp), %eax
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0xa, %eax
andl $0x1f, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x36ffc
movl -0x14(%rbp), %edi
movl $0xffffffe8, %esi       # imm = 0xFFFFFFE8
callq 0x370a0
movsd %xmm0, -0x20(%rbp)
jmp 0x37059
cmpl $0x1f, -0x10(%rbp)
je 0x3701d
movl -0x14(%rbp), %edi
addl $0x400, %edi            # imm = 0x400
movl -0x10(%rbp), %esi
subl $0x19, %esi
callq 0x370a0
movsd %xmm0, -0x20(%rbp)
jmp 0x37057
movl -0x14(%rbp), %eax
movss 0x8ad40(%rip), %xmm0    # 0xc1d68
movss 0x8ad3c(%rip), %xmm1    # 0xc1d6c
movss %xmm1, -0x2c(%rbp)
cmpl $0x0, %eax
movss %xmm0, -0x28(%rbp)
je 0x37049
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x37059
movl -0xc(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x37089
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x37093
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: double cxon::bio::imp::be_to_fp_<double, char const*>(cxon::bio::imp::buffer_<4u, char const*, is_random_access_iterator<char const*>::value> const&)
inline T be_to_fp_(const buffer_<4, II>& bs) {
                using R = unsigned long;
                CXON_ASSERT(sizeof(R) <= sizeof(T), "narrowing");
                union { R i; float f; } u;
                u.i =   (R(bs[3])<< 0) | (R(bs[2])<< 8) |
                        (R(bs[1])<<16) | (R(bs[0])<<24)
                ;
                return static_cast<T>(u.f);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x31da0
movzbl %al, %eax
shlq $0x0, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x31da0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x31da0
movb %al, %cl
movq -0x20(%rbp), %rax
movzbl %cl, %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x31da0
movb %al, %cl
movq -0x18(%rbp), %rax
movzbl %cl, %ecx
shlq $0x18, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: double cxon::bio::imp::be_to_fp_<double, char const*>(cxon::bio::imp::buffer_<8u, char const*, is_random_access_iterator<char const*>::value> const&)
inline T be_to_fp_(const buffer_<8, II>& bs) {
                using R = unsigned long long;
                CXON_ASSERT(sizeof(R) <= sizeof(T), "narrowing");
                union { R i; double f; } u;
                u.i =   (R(bs[7])<< 0) | (R(bs[6])<< 8) |
                        (R(bs[5])<<16) | (R(bs[4])<<24) |
                        (R(bs[3])<<32) | (R(bs[2])<<40) |
                        (R(bs[1])<<48) | (R(bs[0])<<56)
                ;
                return static_cast<T>(u.f);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x7, %esi
callq 0x31fa0
movzbl %al, %eax
shlq $0x0, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x31fa0
movb %al, %cl
movq -0x48(%rbp), %rax
movzbl %cl, %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x31fa0
movb %al, %cl
movq -0x40(%rbp), %rax
movzbl %cl, %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x31fa0
movb %al, %cl
movq -0x38(%rbp), %rax
movzbl %cl, %ecx
shlq $0x18, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x31fa0
movb %al, %cl
movq -0x30(%rbp), %rax
movzbl %cl, %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x31fa0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
shlq $0x28, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x31fa0
movb %al, %cl
movq -0x20(%rbp), %rax
movzbl %cl, %ecx
shlq $0x30, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x31fa0
movb %al, %cl
movq -0x18(%rbp), %rax
movzbl %cl, %ecx
shlq $0x38, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>::reset()
void reset() noexcept {
                switch (kind_) {
#                   define CXON_CBOR_TYPE_DEF(T)    case node_kind::T: value::destruct<T>(*this); break
                        CXON_CBOR_TYPE_DEF(map);
                        CXON_CBOR_TYPE_DEF(array);
                        CXON_CBOR_TYPE_DEF(tag);
                        CXON_CBOR_TYPE_DEF(bytes);
                        CXON_CBOR_TYPE_DEF(text);
                        CXON_CBOR_TYPE_DEF(real);
                        CXON_CBOR_TYPE_DEF(sint);
                        CXON_CBOR_TYPE_DEF(uint);
                        CXON_CBOR_TYPE_DEF(simple);
                        CXON_CBOR_TYPE_DEF(boolean);
                        CXON_CBOR_TYPE_DEF(null);
                        CXON_CBOR_TYPE_DEF(undefined);
#                   undef CXON_CBOR_TYPE_DEF
                }
                kind_ = node_kind::undefined;
            }

// 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 $0xb, %rax
ja 0x3892b
movq -0x10(%rbp), %rax
leaq 0x89724(%rip), %rcx     # 0xc1fc4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x38960
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x38980
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x389a0
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x389c0
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x389e0
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x38a00
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x38a20
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x38a40
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x38a60
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x38a80
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x38aa0
jmp 0x3892b
movq -0x18(%rbp), %rdi
callq 0x38ac0
movq -0x18(%rbp), %rax
movl $0xb, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>::basic_node(cxon::cbor::basic_node<cxon::cbor::ordered_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_CBOR_TYPE_DEF(T)    case node_kind::T: value::move_construct<T>(*this, std::move(o)); break
                        CXON_CBOR_TYPE_DEF(map);
                        CXON_CBOR_TYPE_DEF(array);
                        CXON_CBOR_TYPE_DEF(tag);
                        CXON_CBOR_TYPE_DEF(bytes);
                        CXON_CBOR_TYPE_DEF(text);
                        CXON_CBOR_TYPE_DEF(real);
                        CXON_CBOR_TYPE_DEF(sint);
                        CXON_CBOR_TYPE_DEF(uint);
                        CXON_CBOR_TYPE_DEF(simple);
                        CXON_CBOR_TYPE_DEF(boolean);
                        CXON_CBOR_TYPE_DEF(null);
                        CXON_CBOR_TYPE_DEF(undefined);
#                   undef CXON_CBOR_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 0x3bff0
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0xb, %rax
ja 0x3c737
movq -0x18(%rbp), %rax
leaq 0x85ae9(%rip), %rcx     # 0xc215c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c740
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c770
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c7a0
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c7d0
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c800
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c830
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c860
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c890
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c8c0
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c8f0
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c920
jmp 0x3c737
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c950
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)