LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<is_dynamic_type<cxon::cbor::taggle<unsigned long long, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>>::value && std::integral_constant<bool, true>::value, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>&>::type cxon::value::controller<cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>::move_assign<cxon::cbor::taggle<unsigned long long, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>>(cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>&, cxon::cbor::basic_node<cxon::cbor::ordered_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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x23d2e
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x1a06a
movq (%rbx), %rdi
callq 0x4220
jmp 0x23d3d
movq %rbx, %rdi
callq 0x1a06a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movl $0xb, 0x20(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<!is_dynamic_type<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::value && std::integral_constant<bool, 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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x18e94
movq (%rbx), %rdi
leaq 0x10(%rbx), %r15
cmpq %r15, %rdi
je 0x18e80
callq 0x4220
movq %r15, (%rbx)
movq (%r14), %rcx
leaq 0x10(%r14), %rax
cmpq %rax, %rcx
je 0x18edb
movq %rcx, (%rbx)
jmp 0x18eb9
movq %rbx, %rdi
callq 0x1359a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x18ee4
movq %rdx, (%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
jmp 0x18f00
movups (%rax), %xmm0
movups %xmm0, (%r15)
jmp 0x18eea
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq $0x0, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::__cxx11::basic_string<char, std::char_traits<char>, 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x18fcc
movb (%rax), %cl
jmp 0x18fce
movb $-0x1, %cl
movl %ecx, %edx
andb $-0x20, %dl
cmpb $0x40, %dl
je 0x18fe8
movzbl %dl, %edx
cmpl $0x80, %edx
je 0x19003
cmpl $0x60, %edx
jne 0x19025
andb $0x1f, %cl
movzbl %cl, %ecx
leal -0x1c(%rcx), %edx
cmpl $0x3, %edx
jae 0x19045
callq 0x17f7e
movl $0x6, (%rbx)
jmp 0x19030
movzbl %cl, %esi
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x190e3
callq 0x17f7e
movl $0x7, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1f, %ecx
jne 0x1905b
cmpq %r15, %rax
je 0x1907a
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb (%rax), %bpl
jmp 0x1907d
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x191d4
movb $-0x1, %bpl
movq (%r14), %rax
cmpq %r15, %rax
je 0x19089
movb (%rax), %al
jmp 0x1908b
xorl %eax, %eax
cmpb $-0x1, %al
sete %r13b
je 0x190ca
xorb %bpl, %al
cmpb $0x20, %al
jae 0x190b1
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x191d4
testb %al, %al
jne 0x1907d
jmp 0x190c0
callq 0x17f7e
movl $0x7, (%rbx)
movq %rax, 0x8(%rbx)
testb $0x1, %r13b
je 0x19034
movq (%r14), %rcx
movb $0x1, %al
cmpq %r15, %rcx
je 0x19036
incq %rcx
movq %rcx, (%r14)
jmp 0x19036
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_w_fix_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<unsigned char, std::allocator<unsigned char>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<unsigned char, std::allocator<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_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x18863
testb %al, %al
je 0x23021
subq %rbp, %r13
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
addq %r13, %rcx
movq 0x10(%rsp), %r13
movb $0x1, %al
cmpq %rcx, %r13
ja 0x23030
jmp 0x23049
callq 0x17f7e
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rax
movq %rax, (%r15)
callq 0x17f7e
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
testb %al, %al
je 0x230a6
movq %r12, %rdi
movq %r13, %rsi
callq 0x22d16
testq %r13, %r13
sete %bpl
je 0x230a8
xorl %ebp, %ebp
movq 0x8(%r12), %rsi
cmpq 0x10(%r12), %rsi
je 0x23079
movb $0x0, (%rsi)
incq 0x8(%r12)
jmp 0x23081
movq %r12, %rdi
callq 0x232f8
movq 0x8(%r12), %rdi
decq %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x230be
testb %al, %al
je 0x230a8
decq %r13
sete %bpl
jne 0x23063
jmp 0x230a8
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::cbor::imp::read_integral_<cxon::cbor::format_traits, char, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(char&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_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 %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x1940e
movb (%rax), %cl
andb $-0x20, %cl
jmp 0x19410
movb $-0x20, %cl
cmpb $0x20, %cl
je 0x19433
movzbl %cl, %ecx
testl %ecx, %ecx
jne 0x1955d
cmpq %rdx, %rax
je 0x19446
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movb (%rax), %cl
andb $0x1f, %cl
jmp 0x19448
cmpq %rdx, %rax
je 0x19457
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movb (%rax), %cl
andb $0x1f, %cl
jmp 0x19459
movb $0x1f, %cl
cmpb $0x18, %cl
jae 0x19468
movb %cl, (%r14)
movb $0x1, %al
jmp 0x1959e
movb $0x1f, %cl
cmpb $0x18, %cl
jae 0x194b2
movb %cl, (%r14)
movb $0x1, %al
jmp 0x19597
movzbl %cl, %edi
addl $-0x18, %edi
cmpl $0x4, %edi
jae 0x1955a
addb $-0x18, %cl
movl $0x1, %edi
shll %cl, %edi
decl %edi
cmpl $0x7, %edi
ja 0x1955a
leaq 0x2dfed(%rip), %rcx     # 0x47480
movslq (%rcx,%rdi,4), %rdi
addq %rcx, %rdi
jmpq *%rdi
movq (%rsi), %rcx
cmpq %rdx, %rcx
je 0x1955a
movb (%rcx), %al
movb %al, (%r14)
incq (%rsi)
jmp 0x19450
movzbl %cl, %edi
addl $-0x18, %edi
cmpl $0x4, %edi
jae 0x19583
addb $-0x18, %cl
movl $0x1, %edi
shll %cl, %edi
decl %edi
cmpl $0x7, %edi
ja 0x19583
leaq 0x2df83(%rip), %rcx     # 0x47460
movslq (%rcx,%rdi,4), %rdi
addq %rcx, %rdi
jmpq *%rdi
movq (%rsi), %rcx
cmpq %rdx, %rcx
je 0x19583
movb (%rcx), %al
movb %al, (%r14)
incq (%rsi)
jmp 0x19461
movq (%rsi), %rcx
subq %rcx, %rdx
cmpq $0x4, %rdx
jl 0x1955a
addq $0x4, %rcx
jmp 0x19557
movq (%rsi), %rcx
subq %rcx, %rdx
cmpq $0x4, %rdx
jl 0x19583
addq $0x4, %rcx
jmp 0x19580
movq (%rsi), %rcx
subq %rcx, %rdx
cmpq $0x2, %rdx
jl 0x1955a
addq $0x2, %rcx
jmp 0x19557
movq (%rsi), %rcx
subq %rcx, %rdx
cmpq $0x2, %rdx
jl 0x19583
addq $0x2, %rcx
jmp 0x19580
movq (%rsi), %rcx
subq %rcx, %rdx
cmpq $0x8, %rdx
jl 0x1955a
addq $0x8, %rcx
movq %rcx, (%rsi)
movq %rax, (%rsi)
callq 0x17f7e
movl $0x4, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
jmp 0x1959e
movq (%rsi), %rcx
subq %rcx, %rdx
cmpq $0x8, %rdx
jl 0x19583
addq $0x8, %rcx
movq %rcx, (%rsi)
movq %rax, (%rsi)
callq 0x17f7e
movl $0x4, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
testb %al, %al
je 0x1959e
notb (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x7, %eax
leaq 0x30(%rsp), %rdi
movl %eax, 0x20(%rdi)
movl %eax, 0x28(%rsp)
callq 0x17ac4
testb %al, %al
je 0x197b4
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x12a4c
addq $0x28, %rax
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x17ac4
movl %eax, %ebx
jmp 0x197b6
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x1359a
leaq 0x30(%rsp), %rdi
callq 0x1359a
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1359a
leaq 0x30(%rsp), %rdi
callq 0x1359a
movq %rbx, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x19811
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movb (%rax), %cl
jmp 0x19813
movb $-0x1, %cl
movl %ecx, %ebp
andb $-0x2, %bpl
cmpb $-0xc, %bpl
jne 0x19827
cmpb $-0xc, %cl
setne (%rdi)
jmp 0x19839
movq %rax, (%rsi)
callq 0x17f7e
movl $0x2, (%rbx)
movq %rax, 0x8(%rbx)
cmpb $-0xc, %bpl
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lib/node.cbor.hxx
// Function: bool cxon::read<cxon::CBOR<cxon::cbor::format_traits>, cxon::cbor::simple<unsigned char>, void>::value<char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>, cxon::CBOR<cxon::cbor::format_traits>>(cxon::cbor::simple<unsigned 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 value(cbor::simple<T>& t, II& i, II e, Cx& cx) {
                    II const o = i;
                    auto const b = bio::get(i, e);
                    switch (b & Y::mjr) {
                        case Y::svn:
                            switch (b & 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:
                                    return  (t = T(b & Y::mnr), true);
                                case 0x18:
                                    return  (bio::get(t.value, 1, i, e)) ||
                                            (bio::rewind(i, o), cx/cbor::read_error::unexpected)
                                    ;
                                case 0x14: case 0x15: case 0x16: case 0x17:
                                case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E: case 0x1F:
                                    break;
                            }
                    }
                    return bio::rewind(i, o), cx/cbor::read_error::unexpected;
                }

// Assembly:
pushq %rbx
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x19aba
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movzbl (%rax), %ecx
jmp 0x19abf
movl $0xff, %ecx
movl %ecx, %r8d
notl %r8d
testb $-0x20, %r8b
jne 0x19aec
andl $0x1f, %ecx
movl $0xfffff, %r8d          # imm = 0xFFFFF
btl %ecx, %r8d
jae 0x19ae0
movb %cl, (%rdi)
movb $0x1, %al
jmp 0x19b00
movl $0xfef00000, %r8d       # imm = 0xFEF00000
btl %ecx, %r8d
jae 0x19b02
movq %rax, (%rsi)
callq 0x17f7e
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
movq (%rsi), %rcx
cmpq %rdx, %rcx
je 0x19aec
movb (%rcx), %al
movb %al, (%rdi)
incq (%rsi)
jmp 0x19adc
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::operator==(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&)
bool operator ==(const basic_node& f, const basic_node& s) noexcept {
                    if (f.kind_ != s.kind_)
                        return false;
                    switch (f.kind_) {
#                       define CXON_JSON_TYPE_DEF(T)    case node_kind::T: return f.get<T>() == s.get<T>()
                            CXON_JSON_TYPE_DEF(object);
                            CXON_JSON_TYPE_DEF(array);
                            CXON_JSON_TYPE_DEF(string);
                            CXON_JSON_TYPE_DEF(real);
                            CXON_JSON_TYPE_DEF(sint);
                            CXON_JSON_TYPE_DEF(uint);
                            CXON_JSON_TYPE_DEF(boolean);
                            case node_kind::null: return true;
#                       undef CXON_JSON_TYPE_DEF
                    }
                    return false; // LCOV_EXCL_LINE
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x19c21
cmpl $0x7, %eax
ja 0x19c21
movb $0x1, %bl
movl %eax, %eax
leaq 0x2d965(%rip), %rcx     # 0x474a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x19bf4
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
jmp 0x19c23
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x19bf4
movq (%rdi), %rax
movq (%rsi), %rcx
movq (%rax), %r14
movq 0x8(%rax), %r12
movq %r12, %rax
subq %r14, %rax
movq (%rcx), %r15
movq 0x8(%rcx), %rcx
subq %r15, %rcx
cmpq %rcx, %rax
jne 0x19c21
cmpq %r12, %r14
sete %bl
je 0x19c23
movq %r14, %rdi
movq %r15, %rsi
callq 0x19b13
testb %al, %al
je 0x19c23
addq $0x28, %r14
addq $0x28, %r15
cmpq %r12, %r14
sete %bl
je 0x19c23
movq %r14, %rdi
movq %r15, %rsi
callq 0x19b13
addq $0x28, %r14
addq $0x28, %r15
testb %al, %al
jne 0x19bb7
jmp 0x19c23
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x19c21
testq %rdx, %rdx
je 0x19c23
movq (%rsi), %rsi
movq (%rdi), %rdi
callq 0x4240
testl %eax, %eax
sete %bl
jmp 0x19c23
movq (%rdi), %rax
movq (%rsi), %rcx
movq 0x28(%rax), %rdx
cmpq 0x28(%rcx), %rdx
jne 0x19c21
movq 0x18(%rax), %rdi
addq $0x8, %rax
movq 0x18(%rcx), %rdx
movq %rax, %rsi
callq 0x19c3a
movl %eax, %ebx
jmp 0x19c23
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x8424
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpq $0x4, %rax
ja 0x1a0c7
leaq 0x2d45a(%rip), %rcx     # 0x474d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x1a0d0
jmp 0x1a0bf
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
jne 0x1a0c2
jmp 0x1a0c7
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x1a06a
jmp 0x1a0bf
movq (%rbx), %rdi
testq %rdi, %rdi
jne 0x1a0c2
jmp 0x1a0c7
movq (%rbx), %rdi
callq 0x829e
movq (%rbx), %rdi
callq 0x4220
movl $0xb, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lib/node.json.hxx
// Function: std::enable_if<cxon::JSON<cxon::json::format_traits>::quote_unquoted_keys, bool>::type cxon::cio::key::read<cxon::JSON<cxon::json::format_traits>, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>::key<std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>, cxon::JSON<cxon::json::format_traits>>(cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static auto key(cbor::basic_node<Tr>& t, II& i, II e, Cx& cx)
                            -> enable_if_t< Y::quote_unquoted_keys, bool>
                        {
#                           define CXON_IMBUE(T) t.template imbue<typename cbor::basic_node<Tr>::T>()
                                CXON_IF_CONSTEXPR (Y::unquote_quoted_keys) {
                                    if (!cio::consume<Y>(i, e, cx))
                                        return false;
                                    switch (cio::peek(i, e)) {
                                        case '{': { CXON_NODE_RG();     return read_key_(t, CXON_IMBUE(map),    i, e, cx); }
                                        case '[': { CXON_NODE_RG();     return read_key_(t, CXON_IMBUE(array),  i, e, cx); }
                                    }
                                }
                                return cio::key::read_key<Y>(CXON_IMBUE(text), i, e, cx);
#                           undef CXON_IMBUE
                        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpl $0x4, 0x20(%rdi)
je 0x1aa93
movq %r12, %rdi
callq 0x1a06a
movl $0x4, 0x20(%r12)
leaq 0x10(%r12), %rax
movq %rax, (%r12)
movq $0x0, 0x8(%r12)
movb $0x0, 0x10(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1aaae
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
movl 0x20(%rsi), %eax
cmpq $0xa, %rax
ja 0x1bfa4
leaq 0x2b5bc(%rip), %rcx     # 0x4750c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rdi)
movl $0xb, 0x20(%rsi)
retq
movb (%rsi), %al
movb %al, (%rdi)
retq
movq (%rsi), %rax
movq %rax, (%rdi)
retq
jmp 0x1bfae
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
retq
movq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::write_size<cxon::CBOR<cxon::cbor::format_traits>, std::vector<unsigned char, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char, unsigned long, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool write_size(O& o, bio::byte m, std::size_t s, Cx& cx) {
            unsigned const p = cbor::imp::power_(s);
            return s > 0x17 ?
                bio::poke<X>(o, bio::byte(m + 0x18 + p), cx) && bio::poke<X>(o, s, 1 << p, cx) :
                bio::poke<X>(o, bio::byte(m + s), cx)
            ;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq %rdx, %r15
shrq $0x20, %r15
movl $0x3, %ebp
jne 0x3e1b4
movl $0x2, %ebp
cmpq $0xffff, %rdx           # imm = 0xFFFF
ja 0x3e1b4
xorl %ebp, %ebp
cmpq $0x100, %rdx            # imm = 0x100
setae %bpl
cmpq $0x18, %rdx
jb 0x3e1db
movq %rdx, %r12
movzbl %sil, %eax
addl %ebp, %eax
addb $0x18, %al
movb %al, 0x5(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e1fb
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3e208
addb %sil, %dl
movb %dl, 0x7(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e2ba
movb %dl, (%rsi)
incq 0x8(%rbx)
jmp 0x3e2c7
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e2ea
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
leal -0x1(%rax), %r8d
cmpl $0x7, %r8d
ja 0x3e2d6
leaq 0xa87e(%rip), %rdx      # 0x48aa4
movslq (%rdx,%r8,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movq %r12, %rdx
shrq $0x38, %rdx
movb %dl, 0x8(%rsp)
movq %r12, %rdx
shrq $0x30, %rdx
movb %dl, 0x9(%rsp)
movq %r12, %rdx
shrq $0x28, %rdx
movb %dl, 0xa(%rsp)
movb %r15b, 0xb(%rsp)
movq %r12, %rdi
movl %edi, %edx
shrl $0x18, %edx
leal -0x4(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
movl %edi, %edx
shrl $0x10, %edx
leal -0x3(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
leal -0x2(%rax), %edx
movq %r12, %rcx
movb %ch, 0x8(%rsp,%rdx)
movb %r12b, 0x8(%rsp,%r8)
movl %eax, %r15d
xorl %r12d, %r12d
leaq 0x6(%rsp), %r14
movb 0x8(%rsp,%r12), %al
movb %al, 0x6(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e2a5
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3e2b0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3e2ea
incq %r12
cmpq %r12, %r15
jne 0x3e28a
jmp 0x3e2c7
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e2ea
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1e086
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
xorl %eax, %eax
jmp 0x3e2c9
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/error.hxx
// Function: cxon::cbor::write_error_category::message[abi:cxx11](int) const
std::string message(int ev) const override {
            switch (static_cast<write_error>(ev)) {
                case write_error::ok:               return "no error";
                case write_error::output_failure:   return "output cannot be written";
                case write_error::argument_invalid: return "invalid argument";
                default:                            return "unknown error";
            }
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x2, %edx
je 0x1e0f7
cmpl $0x1, %edx
je 0x1e0e7
testl %edx, %edx
jne 0x1e107
leaq 0x2993f(%rip), %rsi     # 0x47a1d
leaq 0x29940(%rip), %rdx     # 0x47a25
jmp 0x1e115
leaq 0x29b09(%rip), %rsi     # 0x47bf7
leaq 0x29b1a(%rip), %rdx     # 0x47c0f
jmp 0x1e115
leaq 0x29b12(%rip), %rsi     # 0x47c10
leaq 0x29b1b(%rip), %rdx     # 0x47c20
jmp 0x1e115
leaq 0x299c3(%rip), %rsi     # 0x47ad1
leaq 0x299c9(%rip), %rdx     # 0x47ade
movq %rbx, %rdi
callq 0x97fc
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::write<cxon::CBOR<cxon::cbor::format_traits>, long long, void>::value<std::vector<unsigned char, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<unsigned char, std::allocator<unsigned char>>&, long long, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool value(O& o, T t, Cx& cx) {
                auto const m = t < 0 ? (t = -1 - t, X::nint) : X::pint;
                auto const p = cbor::imp::power_(t);
                return t > 0x17 ?
                    bio::poke<X>(o, bio::byte(m + 0x18 + p), cx) && bio::poke<X>(o, t, 1 << p, cx) :
                    bio::poke<X>(o, bio::byte(m + t), cx)
                ;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rax
sarq $0x3f, %rax
xorq %rsi, %rax
shrq $0x3a, %rsi
movq %rax, %r15
shrq $0x20, %r15
movl $0x3, %ebp
jne 0x3e60d
movl $0x2, %ebp
cmpq $0xffff, %rax           # imm = 0xFFFF
ja 0x3e60d
xorl %ebp, %ebp
cmpq $0x100, %rax            # imm = 0x100
setae %bpl
andb $0x20, %sil
cmpq $0x18, %rax
jl 0x3e639
movq %rax, %r12
orb %bpl, %sil
orb $0x18, %sil
movb %sil, 0x5(%rsp)
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x3e65b
movb %sil, (%rax)
incq 0x8(%rbx)
jmp 0x3e66b
addb %al, %sil
movb %sil, 0x7(%rsp)
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x3e71d
movb %sil, (%rax)
incq 0x8(%rbx)
jmp 0x3e72d
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3e2ea
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
leal -0x1(%rax), %r8d
cmpl $0x7, %r8d
ja 0x3e73c
leaq 0xa43b(%rip), %rdx      # 0x48ac4
movslq (%rdx,%r8,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movq %r12, %rdx
shrq $0x38, %rdx
movb %dl, 0x8(%rsp)
movq %r12, %rdx
shrq $0x30, %rdx
movb %dl, 0x9(%rsp)
movq %r12, %rdx
shrq $0x28, %rdx
movb %dl, 0xa(%rsp)
movb %r15b, 0xb(%rsp)
movq %r12, %rdi
movl %edi, %edx
shrl $0x18, %edx
leal -0x4(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
movl %edi, %edx
shrl $0x10, %edx
leal -0x3(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
leal -0x2(%rax), %edx
movq %r12, %rcx
movb %ch, 0x8(%rsp,%rdx)
movb %r12b, 0x8(%rsp,%r8)
movl %eax, %r15d
xorl %r12d, %r12d
leaq 0x6(%rsp), %r14
movb 0x8(%rsp,%r12), %al
movb %al, 0x6(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e708
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3e713
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3e2ea
incq %r12
cmpq %r12, %r15
jne 0x3e6ed
jmp 0x3e72d
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3e2ea
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1e086
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
xorl %eax, %eax
jmp 0x3e72f
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::write<cxon::CBOR<cxon::cbor::format_traits>, unsigned long long, void>::value<std::vector<unsigned char, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned long long, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool value(O& o, T t, Cx& cx) {
                    auto const p = cbor::imp::power_(t);
                    return t > 0x17 ?
                        bio::poke<X>(o, bio::byte(X::pint + 0x18 + p), cx) && bio::poke<X>(o, t, 1 << p, cx) :
                        bio::poke<X>(o, bio::byte(X::pint + t), cx)
                    ;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, %r12
shrq $0x20, %r12
movl $0x3, %r15d
jne 0x3e790
movl $0x2, %r15d
cmpq $0xffff, %rax           # imm = 0xFFFF
ja 0x3e790
xorl %r15d, %r15d
cmpq $0x100, %rax            # imm = 0x100
setae %r15b
cmpq $0x18, %rax
jb 0x3e7b3
movq %rax, %r13
leal 0x18(%r15), %eax
movb %al, 0x5(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e7d0
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3e7dd
movb %al, 0x7(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e890
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3e89d
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e2ea
movl $0x1, %eax
movl %r15d, %ecx
shll %cl, %eax
leal -0x1(%rax), %r8d
cmpl $0x7, %r8d
ja 0x3e8ad
leaq 0xa2e8(%rip), %rdx      # 0x48ae4
movslq (%rdx,%r8,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movq %r13, %rdx
shrq $0x38, %rdx
movb %dl, 0x8(%rsp)
movq %r13, %rdx
shrq $0x30, %rdx
movb %dl, 0x9(%rsp)
movq %r13, %rdx
shrq $0x28, %rdx
movb %dl, 0xa(%rsp)
movb %r12b, 0xb(%rsp)
movq %r13, %rdi
movl %edi, %edx
shrl $0x18, %edx
leal -0x4(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
movl %edi, %edx
shrl $0x10, %edx
leal -0x3(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
leal -0x2(%rax), %edx
movq %r13, %rcx
movb %ch, 0x8(%rsp,%rdx)
movb %r13b, 0x8(%rsp,%r8)
movl %eax, %r15d
xorl %r12d, %r12d
leaq 0x6(%rsp), %r14
movb 0x8(%rsp,%r12), %al
movb %al, 0x6(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e87b
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3e886
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3e2ea
incq %r12
cmpq %r12, %r15
jne 0x3e860
jmp 0x3e89d
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e2ea
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1e086
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
xorl %eax, %eax
jmp 0x3e89f
nop
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lib/node.cbor.hxx
// Function: bool cxon::write<cxon::CBOR<cxon::cbor::format_traits>, cxon::cbor::simple<unsigned char>, void>::value<std::vector<unsigned char, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>, cxon::CBOR<cxon::cbor::format_traits>>(std::vector<unsigned char, std::allocator<unsigned char>>&, cxon::cbor::simple<unsigned char> const&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool value(O& o, const cbor::simple<T>& t, Cx& cx) {
                    switch (t) {
                        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:
                            return  bio::poke<Y>(o, bio::byte(X::svn + t), cx);
                        default:
                            CXON_ASSERT(t <= 255, "invalid simple value");
                            return  bio::poke<Y>(o, bio::byte(X::svn + 0x18), cx) && bio::poke<Y>(o, t.value, 1, cx);
                        case 0x14: case 0x15: case 0x16: case 0x17:
                        case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E: case 0x1F:
                            return  cx/cbor::write_error::argument_invalid;
                    }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpl $0x1f, %eax
ja 0x3e935
movl $0xfffff, %ecx          # imm = 0xFFFFF
btl %eax, %ecx
jae 0x3e8fb
addb $-0x20, %al
movb %al, 0xd(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e91c
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3e929
movl $0xfef00000, %ecx       # imm = 0xFEF00000
btl %eax, %ecx
jae 0x3e935
movq %rdx, %r15
callq 0x1e086
movl $0x2, (%r15)
movq %rax, 0x8(%r15)
xorl %eax, %eax
jmp 0x3e92b
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e2ea
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb $-0x8, 0xe(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e94d
movb $-0x8, (%rsi)
incq 0x8(%rbx)
jmp 0x3e95a
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e2ea
movb (%r14), %al
movb %al, 0xf(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e96f
movb %al, (%rsi)
jmp 0x3e8f5
leaq 0xf(%rsp), %rdx
jmp 0x3e921
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lib/node.json.hxx
// Function: std::enable_if<cxon::JSON<cxon::cio::key::unquoted_traits<cxon::json::format_traits>>::quote_unquoted_keys && std::is_floating_point<double>::value, bool>::type cxon::cio::key::write<cxon::JSON<cxon::cio::key::unquoted_traits<cxon::json::format_traits>>, cxon::json::basic_node<cxon::json::ordered_node_traits<std::allocator<char>>>>::write_key_<cxon::json::indenter<cxon::JSON<cxon::JSON<cxon::json::format_traits>>, std::ostreambuf_iterator<char, std::char_traits<char>>>, double, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>, cxon::JSON<cxon::cio::key::unquoted_traits<cxon::json::format_traits>>>(cxon::json::indenter<cxon::JSON<cxon::JSON<cxon::json::format_traits>>, std::ostreambuf_iterator<char, std::char_traits<char>>>&, double const&, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool write_number_key_(O& o, const T& t, Cx& cx) {
                if (std::isinf(t))
                    return std::signbit(t) ?
                            write_value<X>(o, "-inf", cx) : write_value<X>(o, "inf", cx)
                    ;
                if (std::isnan(t))
                    return  write_value<X>(o, "nan", cx);
                return cio::key::write_key<X>(o, t, cx);
            }

// Assembly:
movq (%rsi), %xmm0
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rsi # imm = 0x7FF0000000000000
cmpq %rsi, %rcx
jne 0x20971
testq %rax, %rax
js 0x2097f
leaq 0x271e5(%rip), %rsi     # 0x47b51
jmp 0x21894
ucomisd %xmm0, %xmm0
jp 0x2098b
movq %rdx, %rsi
jmp 0x21458
leaq 0x271ca(%rip), %rsi     # 0x47b50
jmp 0x217f4
leaq 0x27376(%rip), %rsi     # 0x47d08
jmp 0x21894
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>::operator=(cxon::cbor::basic_node<cxon::cbor::ordered_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_CBOR_TYPE_DEF(T)    case node_kind::T: return value::move_assign<T>(*this, std::move(o))
                        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
                }
                return *this; // LCOV_EXCL_LINE
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rsi), %eax
cmpq $0xb, %rax
ja 0x23c63
movq %rsi, %r14
leaq 0x23c14(%rip), %rcx     # 0x47780
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
cmpl %eax, 0x20(%rbx)
je 0x23b89
movq %rbx, %rdi
callq 0x1a06a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
jmp 0x23c63
cmpl %eax, 0x20(%rbx)
je 0x23ba8
movq %rbx, %rdi
callq 0x1a06a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movb (%r14), %al
movb %al, (%rbx)
jmp 0x23c63
cmpl %eax, 0x20(%rbx)
je 0x23c63
movq %rbx, %rdi
callq 0x1a06a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
jmp 0x23c63
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23db6
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23d06
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23d56
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23c6e
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23cba
cmpl %eax, 0x20(%rbx)
je 0x23c3d
movq %rbx, %rdi
callq 0x1a06a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq $0x0, (%rbx)
jmp 0x23c63
cmpl %eax, 0x20(%rbx)
je 0x23c5a
movq %rbx, %rdi
callq 0x1a06a
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>::operator=(cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>> const&)
basic_node& operator =(const basic_node& o)
                noexcept(value::is_nothrow_copy_assignable<basic_node>::value)
            {
                switch (o.kind_) {
#                   define CXON_CBOR_TYPE_DEF(T)    case node_kind::T: return value::copy_assign<T>(*this, o)
                        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
                }
                return *this; // LCOV_EXCL_LINE
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rsi), %eax
cmpq $0xb, %rax
ja 0x35ba1
movq %rsi, %r14
leaq 0x12aba(%rip), %rcx     # 0x48564
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
cmpl %eax, 0x20(%rbx)
je 0x35ac7
movq %rbx, %rdi
callq 0x364f8
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
jmp 0x35ba1
cmpl %eax, 0x20(%rbx)
je 0x35ae6
movq %rbx, %rdi
callq 0x364f8
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movb (%r14), %al
movb %al, (%rbx)
jmp 0x35ba1
cmpl %eax, 0x20(%rbx)
je 0x35ba1
movq %rbx, %rdi
callq 0x364f8
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
jmp 0x35ba1
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3edf8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3ed3e
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3eda8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3ec7c
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3ecde
cmpl %eax, 0x20(%rbx)
je 0x35b7b
movq %rbx, %rdi
callq 0x364f8
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq $0x0, (%rbx)
jmp 0x35ba1
cmpl %eax, 0x20(%rbx)
je 0x35b98
movq %rbx, %rdi
callq 0x364f8
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>::basic_node(cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>&&, std::allocator<cxon::cbor::basic_node<cxon::cbor::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_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:
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
movl 0x20(%rsi), %eax
cmpq $0xa, %rax
ja 0x35c66
leaq 0x12982(%rip), %rcx     # 0x48594
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rdi)
movl $0xb, 0x20(%rsi)
retq
movb (%rsi), %al
movb %al, (%rdi)
retq
movq (%rsi), %rax
movq %rax, (%rdi)
retq
jmp 0x36f00
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
retq
movq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq